From 9d44980671ef25bb323442df4d5c2841c4ff5e60 Mon Sep 17 00:00:00 2001 From: pmichaud Date: Thu, 3 Jun 2010 16:31:42 -0500 Subject: [PATCH] Update bootstrap. --- src/stage0/HLL-s0.pir | 3229 ++-- src/stage0/NQP-s0.pir | 34588 ++++++++++++++++++----------------- src/stage0/P6Regex-s0.pir | 13725 +++++++------- src/stage0/nqp-setting.nqp | 10 +- 4 files changed, 26214 insertions(+), 25338 deletions(-) diff --git a/src/stage0/HLL-s0.pir b/src/stage0/HLL-s0.pir index 0408c72..c6cfcec 100644 --- a/src/stage0/HLL-s0.pir +++ b/src/stage0/HLL-s0.pir @@ -902,7 +902,7 @@ An operator precedence parser. ### .include 'gen/hllgrammar-grammar.pir' .namespace [] -.sub "_block11" :anon :subid("10_1275511685.92888") +.sub "_block11" :anon :subid("10_1275599990.60173") .annotate 'line', 0 get_hll_global $P14, ["HLL";"Grammar"], "_block13" capture_lex $P14 @@ -916,101 +916,103 @@ An operator precedence parser. .annotate 'line', 5 get_hll_global $P14, ["HLL";"Grammar"], "_block13" capture_lex $P14 - $P343 = $P14() + $P348 = $P14() .annotate 'line', 1 - .return ($P343) - .const 'Sub' $P345 = "104_1275511685.92888" - .return ($P345) + .return ($P348) + .const 'Sub' $P350 = "106_1275599990.60173" + .return ($P350) .end .namespace [] -.sub "" :load :init :subid("post105") :outer("10_1275511685.92888") +.sub "" :load :init :subid("post107") :outer("10_1275599990.60173") .annotate 'line', 0 - .const 'Sub' $P12 = "10_1275511685.92888" + .const 'Sub' $P12 = "10_1275599990.60173" .local pmc block set block, $P12 - $P348 = get_root_global ["parrot"], "P6metaclass" - $P348."new_class"("HLL::Grammar", "Regex::Cursor" :named("parent")) + $P353 = get_root_global ["parrot"], "P6metaclass" + $P353."new_class"("HLL::Grammar", "Regex::Cursor" :named("parent")) .end .namespace ["HLL";"Grammar"] -.sub "_block13" :subid("11_1275511685.92888") :outer("10_1275511685.92888") +.sub "_block13" :subid("11_1275599990.60173") :outer("10_1275599990.60173") .annotate 'line', 5 - .const 'Sub' $P329 = "101_1275511685.92888" - capture_lex $P329 - .const 'Sub' $P322 = "99_1275511685.92888" - capture_lex $P322 - .const 'Sub' $P309 = "96_1275511685.92888" - capture_lex $P309 - .const 'Sub' $P277 = "91_1275511685.92888" - capture_lex $P277 - .const 'Sub' $P271 = "89_1275511685.92888" + .const 'Sub' $P334 = "103_1275599990.60173" + capture_lex $P334 + .const 'Sub' $P327 = "101_1275599990.60173" + capture_lex $P327 + .const 'Sub' $P314 = "98_1275599990.60173" + capture_lex $P314 + .const 'Sub' $P282 = "93_1275599990.60173" + capture_lex $P282 + .const 'Sub' $P276 = "91_1275599990.60173" + capture_lex $P276 + .const 'Sub' $P271 = "89_1275599990.60173" capture_lex $P271 - .const 'Sub' $P266 = "87_1275511685.92888" - capture_lex $P266 - .const 'Sub' $P260 = "85_1275511685.92888" - capture_lex $P260 - .const 'Sub' $P254 = "83_1275511685.92888" + .const 'Sub' $P265 = "87_1275599990.60173" + capture_lex $P265 + .const 'Sub' $P259 = "85_1275599990.60173" + capture_lex $P259 + .const 'Sub' $P254 = "83_1275599990.60173" capture_lex $P254 - .const 'Sub' $P249 = "81_1275511685.92888" + .const 'Sub' $P249 = "81_1275599990.60173" capture_lex $P249 - .const 'Sub' $P244 = "79_1275511685.92888" + .const 'Sub' $P244 = "79_1275599990.60173" capture_lex $P244 - .const 'Sub' $P239 = "77_1275511685.92888" + .const 'Sub' $P239 = "77_1275599990.60173" capture_lex $P239 - .const 'Sub' $P234 = "75_1275511685.92888" + .const 'Sub' $P234 = "75_1275599990.60173" capture_lex $P234 - .const 'Sub' $P229 = "73_1275511685.92888" + .const 'Sub' $P229 = "73_1275599990.60173" capture_lex $P229 - .const 'Sub' $P224 = "71_1275511685.92888" + .const 'Sub' $P224 = "71_1275599990.60173" capture_lex $P224 - .const 'Sub' $P219 = "69_1275511685.92888" + .const 'Sub' $P219 = "69_1275599990.60173" capture_lex $P219 - .const 'Sub' $P208 = "65_1275511685.92888" + .const 'Sub' $P208 = "65_1275599990.60173" capture_lex $P208 - .const 'Sub' $P195 = "63_1275511685.92888" + .const 'Sub' $P195 = "63_1275599990.60173" capture_lex $P195 - .const 'Sub' $P183 = "61_1275511685.92888" + .const 'Sub' $P183 = "61_1275599990.60173" capture_lex $P183 - .const 'Sub' $P176 = "59_1275511685.92888" + .const 'Sub' $P176 = "59_1275599990.60173" capture_lex $P176 - .const 'Sub' $P167 = "57_1275511685.92888" + .const 'Sub' $P167 = "57_1275599990.60173" capture_lex $P167 - .const 'Sub' $P160 = "55_1275511685.92888" + .const 'Sub' $P160 = "55_1275599990.60173" capture_lex $P160 - .const 'Sub' $P151 = "53_1275511685.92888" + .const 'Sub' $P151 = "53_1275599990.60173" capture_lex $P151 - .const 'Sub' $P144 = "51_1275511685.92888" + .const 'Sub' $P144 = "51_1275599990.60173" capture_lex $P144 - .const 'Sub' $P135 = "49_1275511685.92888" + .const 'Sub' $P135 = "49_1275599990.60173" capture_lex $P135 - .const 'Sub' $P128 = "47_1275511685.92888" + .const 'Sub' $P128 = "47_1275599990.60173" capture_lex $P128 - .const 'Sub' $P121 = "45_1275511685.92888" + .const 'Sub' $P121 = "45_1275599990.60173" capture_lex $P121 - .const 'Sub' $P111 = "43_1275511685.92888" + .const 'Sub' $P111 = "43_1275599990.60173" capture_lex $P111 - .const 'Sub' $P103 = "41_1275511685.92888" + .const 'Sub' $P103 = "41_1275599990.60173" capture_lex $P103 - .const 'Sub' $P93 = "40_1275511685.92888" + .const 'Sub' $P93 = "40_1275599990.60173" capture_lex $P93 - .const 'Sub' $P87 = "38_1275511685.92888" + .const 'Sub' $P87 = "38_1275599990.60173" capture_lex $P87 - .const 'Sub' $P82 = "36_1275511685.92888" + .const 'Sub' $P82 = "36_1275599990.60173" capture_lex $P82 - .const 'Sub' $P74 = "34_1275511685.92888" + .const 'Sub' $P74 = "34_1275599990.60173" capture_lex $P74 - .const 'Sub' $P68 = "32_1275511685.92888" + .const 'Sub' $P68 = "32_1275599990.60173" capture_lex $P68 - .const 'Sub' $P62 = "30_1275511685.92888" + .const 'Sub' $P62 = "30_1275599990.60173" capture_lex $P62 - .const 'Sub' $P56 = "28_1275511685.92888" + .const 'Sub' $P56 = "28_1275599990.60173" capture_lex $P56 - .const 'Sub' $P23 = "14_1275511685.92888" + .const 'Sub' $P23 = "14_1275599990.60173" capture_lex $P23 - .const 'Sub' $P15 = "12_1275511685.92888" + .const 'Sub' $P15 = "12_1275599990.60173" capture_lex $P15 $P0 = find_dynamic_lex "$*CTXSAVE" if null $P0 goto ctxsave_done @@ -1019,17 +1021,17 @@ An operator precedence parser. $P0."ctxsave"() ctxsave_done: .annotate 'line', 33 - .const 'Sub' $P329 = "101_1275511685.92888" - capture_lex $P329 + .const 'Sub' $P334 = "103_1275599990.60173" + capture_lex $P334 .annotate 'line', 5 - .return ($P329) - .const 'Sub' $P340 = "103_1275511685.92888" - .return ($P340) + .return ($P334) + .const 'Sub' $P345 = "105_1275599990.60173" + .return ($P345) .end .namespace ["HLL";"Grammar"] -.sub "ws" :subid("12_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "ws" :subid("12_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 5 .local string rx16_tgt .local int rx16_pos @@ -1114,7 +1116,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__ws" :subid("13_1275511685.92888") :method +.sub "!PREFIX__ws" :subid("13_1275599990.60173") :method .annotate 'line', 5 new $P18, "ResizablePMCArray" push $P18, "" @@ -1123,7 +1125,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "termish" :subid("14_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "termish" :subid("14_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 5 .local string rx24_tgt .local int rx24_pos @@ -1133,7 +1135,7 @@ An operator precedence parser. .local pmc rx24_cur (rx24_cur, rx24_pos, rx24_tgt) = self."!cursor_start"() rx24_cur."!cursor_debug"("START ", "termish") - rx24_cur."!cursor_caparray"("prefixish", "postfixish") + rx24_cur."!cursor_caparray"("postfixish", "prefixish") .lex unicode:"$\x{a2}", rx24_cur .local pmc match .lex "$/", match @@ -1216,7 +1218,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__termish" :subid("15_1275511685.92888") :method +.sub "!PREFIX__termish" :subid("15_1275599990.60173") :method .annotate 'line', 5 new $P26, "ResizablePMCArray" push $P26, "" @@ -1225,7 +1227,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "term" :subid("16_1275511685.92888") :method +.sub "term" :subid("16_1275599990.60173") :method .annotate 'line', 13 $P33 = self."!protoregex"("term") .return ($P33) @@ -1233,7 +1235,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__term" :subid("17_1275511685.92888") :method +.sub "!PREFIX__term" :subid("17_1275599990.60173") :method .annotate 'line', 13 $P35 = self."!PREFIX__!protoregex"("term") .return ($P35) @@ -1241,7 +1243,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "infix" :subid("18_1275511685.92888") :method +.sub "infix" :subid("18_1275599990.60173") :method .annotate 'line', 14 $P37 = self."!protoregex"("infix") .return ($P37) @@ -1249,7 +1251,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__infix" :subid("19_1275511685.92888") :method +.sub "!PREFIX__infix" :subid("19_1275599990.60173") :method .annotate 'line', 14 $P39 = self."!PREFIX__!protoregex"("infix") .return ($P39) @@ -1257,7 +1259,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "prefix" :subid("20_1275511685.92888") :method +.sub "prefix" :subid("20_1275599990.60173") :method .annotate 'line', 15 $P41 = self."!protoregex"("prefix") .return ($P41) @@ -1265,7 +1267,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__prefix" :subid("21_1275511685.92888") :method +.sub "!PREFIX__prefix" :subid("21_1275599990.60173") :method .annotate 'line', 15 $P43 = self."!PREFIX__!protoregex"("prefix") .return ($P43) @@ -1273,7 +1275,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "postfix" :subid("22_1275511685.92888") :method +.sub "postfix" :subid("22_1275599990.60173") :method .annotate 'line', 16 $P45 = self."!protoregex"("postfix") .return ($P45) @@ -1281,7 +1283,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__postfix" :subid("23_1275511685.92888") :method +.sub "!PREFIX__postfix" :subid("23_1275599990.60173") :method .annotate 'line', 16 $P47 = self."!PREFIX__!protoregex"("postfix") .return ($P47) @@ -1289,7 +1291,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "circumfix" :subid("24_1275511685.92888") :method +.sub "circumfix" :subid("24_1275599990.60173") :method .annotate 'line', 17 $P49 = self."!protoregex"("circumfix") .return ($P49) @@ -1297,7 +1299,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__circumfix" :subid("25_1275511685.92888") :method +.sub "!PREFIX__circumfix" :subid("25_1275599990.60173") :method .annotate 'line', 17 $P51 = self."!PREFIX__!protoregex"("circumfix") .return ($P51) @@ -1305,7 +1307,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "postcircumfix" :subid("26_1275511685.92888") :method +.sub "postcircumfix" :subid("26_1275599990.60173") :method .annotate 'line', 18 $P53 = self."!protoregex"("postcircumfix") .return ($P53) @@ -1313,7 +1315,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__postcircumfix" :subid("27_1275511685.92888") :method +.sub "!PREFIX__postcircumfix" :subid("27_1275599990.60173") :method .annotate 'line', 18 $P55 = self."!PREFIX__!protoregex"("postcircumfix") .return ($P55) @@ -1321,7 +1323,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "term:sym" :subid("28_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "term:sym" :subid("28_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 5 .local string rx57_tgt .local int rx57_pos @@ -1380,7 +1382,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__term:sym" :subid("29_1275511685.92888") :method +.sub "!PREFIX__term:sym" :subid("29_1275599990.60173") :method .annotate 'line', 5 $P59 = self."!PREFIX__!subrule"("circumfix", "") new $P60, "ResizablePMCArray" @@ -1390,7 +1392,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "infixish" :subid("30_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "infixish" :subid("30_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 5 .local string rx63_tgt .local int rx63_pos @@ -1449,7 +1451,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__infixish" :subid("31_1275511685.92888") :method +.sub "!PREFIX__infixish" :subid("31_1275599990.60173") :method .annotate 'line', 5 $P65 = self."!PREFIX__!subrule"("OPER=infix", "") new $P66, "ResizablePMCArray" @@ -1459,7 +1461,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "prefixish" :subid("32_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "prefixish" :subid("32_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 5 .local string rx69_tgt .local int rx69_pos @@ -1523,7 +1525,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__prefixish" :subid("33_1275511685.92888") :method +.sub "!PREFIX__prefixish" :subid("33_1275599990.60173") :method .annotate 'line', 5 $P71 = self."!PREFIX__!subrule"("OPER=prefix", "") new $P72, "ResizablePMCArray" @@ -1533,7 +1535,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "postfixish" :subid("34_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "postfixish" :subid("34_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 5 .local string rx75_tgt .local int rx75_pos @@ -1608,7 +1610,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__postfixish" :subid("35_1275511685.92888") :method +.sub "!PREFIX__postfixish" :subid("35_1275599990.60173") :method .annotate 'line', 5 $P77 = self."!PREFIX__!subrule"("OPER=postcircumfix", "") $P78 = self."!PREFIX__!subrule"("OPER=postfix", "") @@ -1620,7 +1622,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "nullterm" :subid("36_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "nullterm" :subid("36_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 5 .local string rx83_tgt .local int rx83_pos @@ -1672,7 +1674,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__nullterm" :subid("37_1275511685.92888") :method +.sub "!PREFIX__nullterm" :subid("37_1275599990.60173") :method .annotate 'line', 5 new $P85, "ResizablePMCArray" push $P85, "" @@ -1681,7 +1683,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "nullterm_alt" :subid("38_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "nullterm_alt" :subid("38_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 5 .local string rx88_tgt .local int rx88_pos @@ -1740,7 +1742,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__nullterm_alt" :subid("39_1275511685.92888") :method +.sub "!PREFIX__nullterm_alt" :subid("39_1275599990.60173") :method .annotate 'line', 5 $P90 = self."!PREFIX__!subrule"("term", "") new $P91, "ResizablePMCArray" @@ -1750,7 +1752,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "nulltermish" :subid("40_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "nulltermish" :subid("40_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 new $P95, 'ExceptionHandler' set_addr $P95, control_94 @@ -1777,7 +1779,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "quote_delimited" :subid("41_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_delimited" :subid("41_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx104_tgt .local int rx104_pos @@ -1860,7 +1862,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_delimited" :subid("42_1275511685.92888") :method +.sub "!PREFIX__quote_delimited" :subid("42_1275599990.60173") :method .annotate 'line', 33 $P106 = self."!PREFIX__!subrule"("starter", "") new $P107, "ResizablePMCArray" @@ -1870,7 +1872,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "quote_atom" :subid("43_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_atom" :subid("43_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx112_tgt .local int rx112_pos @@ -1962,7 +1964,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_atom" :subid("44_1275511685.92888") :method +.sub "!PREFIX__quote_atom" :subid("44_1275599990.60173") :method .annotate 'line', 33 new $P114, "ResizablePMCArray" push $P114, "" @@ -1971,7 +1973,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "decint" :subid("45_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "decint" :subid("45_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx122_tgt .local int rx122_pos @@ -2044,7 +2046,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__decint" :subid("46_1275511685.92888") :method +.sub "!PREFIX__decint" :subid("46_1275599990.60173") :method .annotate 'line', 33 new $P124, "ResizablePMCArray" push $P124, "" @@ -2053,7 +2055,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "decints" :subid("47_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "decints" :subid("47_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx129_tgt .local int rx129_pos @@ -2138,7 +2140,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__decints" :subid("48_1275511685.92888") :method +.sub "!PREFIX__decints" :subid("48_1275599990.60173") :method .annotate 'line', 33 new $P131, "ResizablePMCArray" push $P131, "" @@ -2147,7 +2149,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "hexint" :subid("49_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "hexint" :subid("49_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx136_tgt .local int rx136_pos @@ -2229,7 +2231,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__hexint" :subid("50_1275511685.92888") :method +.sub "!PREFIX__hexint" :subid("50_1275599990.60173") :method .annotate 'line', 33 new $P138, "ResizablePMCArray" push $P138, "" @@ -2238,7 +2240,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "hexints" :subid("51_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "hexints" :subid("51_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx145_tgt .local int rx145_pos @@ -2323,7 +2325,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__hexints" :subid("52_1275511685.92888") :method +.sub "!PREFIX__hexints" :subid("52_1275599990.60173") :method .annotate 'line', 33 new $P147, "ResizablePMCArray" push $P147, "" @@ -2332,7 +2334,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "octint" :subid("53_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "octint" :subid("53_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx152_tgt .local int rx152_pos @@ -2414,7 +2416,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__octint" :subid("54_1275511685.92888") :method +.sub "!PREFIX__octint" :subid("54_1275599990.60173") :method .annotate 'line', 33 new $P154, "ResizablePMCArray" push $P154, "" @@ -2423,7 +2425,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "octints" :subid("55_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "octints" :subid("55_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx161_tgt .local int rx161_pos @@ -2508,7 +2510,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__octints" :subid("56_1275511685.92888") :method +.sub "!PREFIX__octints" :subid("56_1275599990.60173") :method .annotate 'line', 33 new $P163, "ResizablePMCArray" push $P163, "" @@ -2517,7 +2519,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "binint" :subid("57_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "binint" :subid("57_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx168_tgt .local int rx168_pos @@ -2599,7 +2601,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__binint" :subid("58_1275511685.92888") :method +.sub "!PREFIX__binint" :subid("58_1275599990.60173") :method .annotate 'line', 33 new $P170, "ResizablePMCArray" push $P170, "" @@ -2608,7 +2610,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "binints" :subid("59_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "binints" :subid("59_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx177_tgt .local int rx177_pos @@ -2693,7 +2695,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__binints" :subid("60_1275511685.92888") :method +.sub "!PREFIX__binints" :subid("60_1275599990.60173") :method .annotate 'line', 33 new $P179, "ResizablePMCArray" push $P179, "" @@ -2702,7 +2704,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "integer" :subid("61_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "integer" :subid("61_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx184_tgt .local int rx184_pos @@ -2851,7 +2853,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__integer" :subid("62_1275511685.92888") :method +.sub "!PREFIX__integer" :subid("62_1275599990.60173") :method .annotate 'line', 33 $P186 = self."!PREFIX__!subrule"("VALUE=decint", "") $P187 = self."!PREFIX__!subrule"("VALUE=decint", "0d") @@ -2869,7 +2871,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "dec_number" :subid("63_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "dec_number" :subid("63_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx196_tgt .local int rx196_pos @@ -3049,7 +3051,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__dec_number" :subid("64_1275511685.92888") :method +.sub "!PREFIX__dec_number" :subid("64_1275599990.60173") :method .annotate 'line', 33 new $P198, "ResizablePMCArray" push $P198, "" @@ -3060,7 +3062,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "escale" :subid("65_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "escale" :subid("65_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx209_tgt .local int rx209_pos @@ -3138,7 +3140,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__escale" :subid("66_1275511685.92888") :method +.sub "!PREFIX__escale" :subid("66_1275599990.60173") :method .annotate 'line', 33 new $P211, "ResizablePMCArray" push $P211, "e" @@ -3148,7 +3150,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "quote_escape" :subid("67_1275511685.92888") :method +.sub "quote_escape" :subid("67_1275599990.60173") :method .annotate 'line', 79 $P216 = self."!protoregex"("quote_escape") .return ($P216) @@ -3156,7 +3158,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_escape" :subid("68_1275511685.92888") :method +.sub "!PREFIX__quote_escape" :subid("68_1275599990.60173") :method .annotate 'line', 79 $P218 = self."!PREFIX__!protoregex"("quote_escape") .return ($P218) @@ -3164,7 +3166,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "quote_escape:sym" :subid("69_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_escape:sym" :subid("69_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx220_tgt .local int rx220_pos @@ -3227,7 +3229,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_escape:sym" :subid("70_1275511685.92888") :method +.sub "!PREFIX__quote_escape:sym" :subid("70_1275599990.60173") :method .annotate 'line', 33 new $P222, "ResizablePMCArray" push $P222, "\\\\" @@ -3236,7 +3238,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "quote_escape:sym" :subid("71_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_escape:sym" :subid("71_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx225_tgt .local int rx225_pos @@ -3306,7 +3308,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_escape:sym" :subid("72_1275511685.92888") :method +.sub "!PREFIX__quote_escape:sym" :subid("72_1275599990.60173") :method .annotate 'line', 33 new $P227, "ResizablePMCArray" push $P227, "\\" @@ -3315,7 +3317,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "quote_escape:sym" :subid("73_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_escape:sym" :subid("73_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx230_tgt .local int rx230_pos @@ -3378,7 +3380,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_escape:sym" :subid("74_1275511685.92888") :method +.sub "!PREFIX__quote_escape:sym" :subid("74_1275599990.60173") :method .annotate 'line', 33 new $P232, "ResizablePMCArray" push $P232, "\\b" @@ -3387,7 +3389,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "quote_escape:sym" :subid("75_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_escape:sym" :subid("75_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx235_tgt .local int rx235_pos @@ -3450,7 +3452,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_escape:sym" :subid("76_1275511685.92888") :method +.sub "!PREFIX__quote_escape:sym" :subid("76_1275599990.60173") :method .annotate 'line', 33 new $P237, "ResizablePMCArray" push $P237, "\\n" @@ -3459,7 +3461,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "quote_escape:sym" :subid("77_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_escape:sym" :subid("77_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx240_tgt .local int rx240_pos @@ -3522,7 +3524,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_escape:sym" :subid("78_1275511685.92888") :method +.sub "!PREFIX__quote_escape:sym" :subid("78_1275599990.60173") :method .annotate 'line', 33 new $P242, "ResizablePMCArray" push $P242, "\\r" @@ -3531,7 +3533,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "quote_escape:sym" :subid("79_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_escape:sym" :subid("79_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx245_tgt .local int rx245_pos @@ -3594,7 +3596,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_escape:sym" :subid("80_1275511685.92888") :method +.sub "!PREFIX__quote_escape:sym" :subid("80_1275599990.60173") :method .annotate 'line', 33 new $P247, "ResizablePMCArray" push $P247, "\\t" @@ -3603,7 +3605,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "quote_escape:sym" :subid("81_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_escape:sym" :subid("81_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx250_tgt .local int rx250_pos @@ -3666,7 +3668,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_escape:sym" :subid("82_1275511685.92888") :method +.sub "!PREFIX__quote_escape:sym" :subid("82_1275599990.60173") :method .annotate 'line', 33 new $P252, "ResizablePMCArray" push $P252, "\\f" @@ -3675,7 +3677,7 @@ An operator precedence parser. .namespace ["HLL";"Grammar"] -.sub "quote_escape:sym" :subid("83_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_escape:sym" :subid("83_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx255_tgt .local int rx255_pos @@ -3684,7 +3686,7 @@ An operator precedence parser. .local int rx255_rep .local pmc rx255_cur (rx255_cur, rx255_pos, rx255_tgt) = self."!cursor_start"() - rx255_cur."!cursor_debug"("START ", "quote_escape:sym") + rx255_cur."!cursor_debug"("START ", "quote_escape:sym") .lex unicode:"$\x{a2}", rx255_cur .local pmc match .lex "$/", match @@ -3707,57 +3709,21 @@ An operator precedence parser. set_addr $I10, rxscan258_loop rx255_cur."!mark_push"(0, rx255_pos, $I10) rxscan258_done: -.annotate 'line', 89 - # rx literal unicode:"\\x" +.annotate 'line', 88 + # rx literal "\\e" add $I11, rx255_pos, 2 gt $I11, rx255_eos, rx255_fail sub $I11, rx255_pos, rx255_off substr $S10, rx255_tgt, $I11, 2 - ne $S10, unicode:"\\x", rx255_fail + ne $S10, "\\e", rx255_fail add rx255_pos, 2 # rx subrule "quotemod_check" subtype=zerowidth negate= rx255_cur."!cursor_pos"(rx255_pos) $P10 = rx255_cur."quotemod_check"("b") unless $P10, rx255_fail - alt259_0: -.annotate 'line', 90 - set_addr $I10, alt259_1 - rx255_cur."!mark_push"(0, rx255_pos, $I10) - # rx subrule "hexint" subtype=capture negate= - rx255_cur."!cursor_pos"(rx255_pos) - $P10 = rx255_cur."hexint"() - unless $P10, rx255_fail - rx255_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("hexint") - rx255_pos = $P10."pos"() - goto alt259_end - alt259_1: - # rx literal "[" - add $I11, rx255_pos, 1 - gt $I11, rx255_eos, rx255_fail - sub $I11, rx255_pos, rx255_off - substr $S10, rx255_tgt, $I11, 1 - ne $S10, "[", rx255_fail - add rx255_pos, 1 - # rx subrule "hexints" subtype=capture negate= - rx255_cur."!cursor_pos"(rx255_pos) - $P10 = rx255_cur."hexints"() - unless $P10, rx255_fail - rx255_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("hexints") - rx255_pos = $P10."pos"() - # rx literal "]" - add $I11, rx255_pos, 1 - gt $I11, rx255_eos, rx255_fail - sub $I11, rx255_pos, rx255_off - substr $S10, rx255_tgt, $I11, 1 - ne $S10, "]", rx255_fail - add rx255_pos, 1 - alt259_end: -.annotate 'line', 88 # rx pass - rx255_cur."!cursor_pass"(rx255_pos, "quote_escape:sym") - rx255_cur."!cursor_debug"("PASS ", "quote_escape:sym", " at pos=", rx255_pos) + rx255_cur."!cursor_pass"(rx255_pos, "quote_escape:sym") + rx255_cur."!cursor_debug"("PASS ", "quote_escape:sym", " at pos=", rx255_pos) .return (rx255_cur) rx255_fail: .annotate 'line', 33 @@ -3767,210 +3733,239 @@ An operator precedence parser. jump $I10 rx255_done: rx255_cur."!cursor_fail"() - rx255_cur."!cursor_debug"("FAIL ", "quote_escape:sym") + rx255_cur."!cursor_debug"("FAIL ", "quote_escape:sym") .return (rx255_cur) .return () .end .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_escape:sym" :subid("84_1275511685.92888") :method +.sub "!PREFIX__quote_escape:sym" :subid("84_1275599990.60173") :method .annotate 'line', 33 new $P257, "ResizablePMCArray" - push $P257, unicode:"\\x" + push $P257, "\\e" .return ($P257) .end .namespace ["HLL";"Grammar"] -.sub "quote_escape:sym" :subid("85_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_escape:sym" :subid("85_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 - .local string rx261_tgt - .local int rx261_pos - .local int rx261_off - .local int rx261_eos - .local int rx261_rep - .local pmc rx261_cur - (rx261_cur, rx261_pos, rx261_tgt) = self."!cursor_start"() - rx261_cur."!cursor_debug"("START ", "quote_escape:sym") - .lex unicode:"$\x{a2}", rx261_cur + .local string rx260_tgt + .local int rx260_pos + .local int rx260_off + .local int rx260_eos + .local int rx260_rep + .local pmc rx260_cur + (rx260_cur, rx260_pos, rx260_tgt) = self."!cursor_start"() + rx260_cur."!cursor_debug"("START ", "quote_escape:sym") + .lex unicode:"$\x{a2}", rx260_cur .local pmc match .lex "$/", match - length rx261_eos, rx261_tgt - gt rx261_pos, rx261_eos, rx261_done - set rx261_off, 0 - lt rx261_pos, 2, rx261_start - sub rx261_off, rx261_pos, 1 - substr rx261_tgt, rx261_tgt, rx261_off - rx261_start: + length rx260_eos, rx260_tgt + gt rx260_pos, rx260_eos, rx260_done + set rx260_off, 0 + lt rx260_pos, 2, rx260_start + sub rx260_off, rx260_pos, 1 + substr rx260_tgt, rx260_tgt, rx260_off + rx260_start: $I10 = self.'from'() - ne $I10, -1, rxscan264_done - goto rxscan264_scan - rxscan264_loop: - ($P10) = rx261_cur."from"() + ne $I10, -1, rxscan263_done + goto rxscan263_scan + rxscan263_loop: + ($P10) = rx260_cur."from"() inc $P10 - set rx261_pos, $P10 - ge rx261_pos, rx261_eos, rxscan264_done - rxscan264_scan: - set_addr $I10, rxscan264_loop - rx261_cur."!mark_push"(0, rx261_pos, $I10) - rxscan264_done: -.annotate 'line', 93 - # rx literal "\\o" - add $I11, rx261_pos, 2 - gt $I11, rx261_eos, rx261_fail - sub $I11, rx261_pos, rx261_off - substr $S10, rx261_tgt, $I11, 2 - ne $S10, "\\o", rx261_fail - add rx261_pos, 2 + set rx260_pos, $P10 + ge rx260_pos, rx260_eos, rxscan263_done + rxscan263_scan: + set_addr $I10, rxscan263_loop + rx260_cur."!mark_push"(0, rx260_pos, $I10) + rxscan263_done: +.annotate 'line', 90 + # rx literal unicode:"\\x" + add $I11, rx260_pos, 2 + gt $I11, rx260_eos, rx260_fail + sub $I11, rx260_pos, rx260_off + substr $S10, rx260_tgt, $I11, 2 + ne $S10, unicode:"\\x", rx260_fail + add rx260_pos, 2 # rx subrule "quotemod_check" subtype=zerowidth negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."quotemod_check"("b") - unless $P10, rx261_fail - alt265_0: -.annotate 'line', 94 - set_addr $I10, alt265_1 - rx261_cur."!mark_push"(0, rx261_pos, $I10) - # rx subrule "octint" subtype=capture negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."octint"() - unless $P10, rx261_fail - rx261_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("octint") - rx261_pos = $P10."pos"() - goto alt265_end - alt265_1: + rx260_cur."!cursor_pos"(rx260_pos) + $P10 = rx260_cur."quotemod_check"("b") + unless $P10, rx260_fail + alt264_0: +.annotate 'line', 91 + set_addr $I10, alt264_1 + rx260_cur."!mark_push"(0, rx260_pos, $I10) + # rx subrule "hexint" subtype=capture negate= + rx260_cur."!cursor_pos"(rx260_pos) + $P10 = rx260_cur."hexint"() + unless $P10, rx260_fail + rx260_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("hexint") + rx260_pos = $P10."pos"() + goto alt264_end + alt264_1: # rx literal "[" - add $I11, rx261_pos, 1 - gt $I11, rx261_eos, rx261_fail - sub $I11, rx261_pos, rx261_off - substr $S10, rx261_tgt, $I11, 1 - ne $S10, "[", rx261_fail - add rx261_pos, 1 - # rx subrule "octints" subtype=capture negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."octints"() - unless $P10, rx261_fail - rx261_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("octints") - rx261_pos = $P10."pos"() + add $I11, rx260_pos, 1 + gt $I11, rx260_eos, rx260_fail + sub $I11, rx260_pos, rx260_off + substr $S10, rx260_tgt, $I11, 1 + ne $S10, "[", rx260_fail + add rx260_pos, 1 + # rx subrule "hexints" subtype=capture negate= + rx260_cur."!cursor_pos"(rx260_pos) + $P10 = rx260_cur."hexints"() + unless $P10, rx260_fail + rx260_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("hexints") + rx260_pos = $P10."pos"() # rx literal "]" - add $I11, rx261_pos, 1 - gt $I11, rx261_eos, rx261_fail - sub $I11, rx261_pos, rx261_off - substr $S10, rx261_tgt, $I11, 1 - ne $S10, "]", rx261_fail - add rx261_pos, 1 - alt265_end: -.annotate 'line', 92 + add $I11, rx260_pos, 1 + gt $I11, rx260_eos, rx260_fail + sub $I11, rx260_pos, rx260_off + substr $S10, rx260_tgt, $I11, 1 + ne $S10, "]", rx260_fail + add rx260_pos, 1 + alt264_end: +.annotate 'line', 89 # rx pass - rx261_cur."!cursor_pass"(rx261_pos, "quote_escape:sym") - rx261_cur."!cursor_debug"("PASS ", "quote_escape:sym", " at pos=", rx261_pos) - .return (rx261_cur) - rx261_fail: + rx260_cur."!cursor_pass"(rx260_pos, "quote_escape:sym") + rx260_cur."!cursor_debug"("PASS ", "quote_escape:sym", " at pos=", rx260_pos) + .return (rx260_cur) + rx260_fail: .annotate 'line', 33 - (rx261_rep, rx261_pos, $I10, $P10) = rx261_cur."!mark_fail"(0) - lt rx261_pos, -1, rx261_done - eq rx261_pos, -1, rx261_fail + (rx260_rep, rx260_pos, $I10, $P10) = rx260_cur."!mark_fail"(0) + lt rx260_pos, -1, rx260_done + eq rx260_pos, -1, rx260_fail jump $I10 - rx261_done: - rx261_cur."!cursor_fail"() - rx261_cur."!cursor_debug"("FAIL ", "quote_escape:sym") - .return (rx261_cur) + rx260_done: + rx260_cur."!cursor_fail"() + rx260_cur."!cursor_debug"("FAIL ", "quote_escape:sym") + .return (rx260_cur) .return () .end .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_escape:sym" :subid("86_1275511685.92888") :method +.sub "!PREFIX__quote_escape:sym" :subid("86_1275599990.60173") :method .annotate 'line', 33 - new $P263, "ResizablePMCArray" - push $P263, "\\o" - .return ($P263) + new $P262, "ResizablePMCArray" + push $P262, unicode:"\\x" + .return ($P262) .end .namespace ["HLL";"Grammar"] -.sub "quote_escape:sym" :subid("87_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_escape:sym" :subid("87_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 - .local string rx267_tgt - .local int rx267_pos - .local int rx267_off - .local int rx267_eos - .local int rx267_rep - .local pmc rx267_cur - (rx267_cur, rx267_pos, rx267_tgt) = self."!cursor_start"() - rx267_cur."!cursor_debug"("START ", "quote_escape:sym") - .lex unicode:"$\x{a2}", rx267_cur + .local string rx266_tgt + .local int rx266_pos + .local int rx266_off + .local int rx266_eos + .local int rx266_rep + .local pmc rx266_cur + (rx266_cur, rx266_pos, rx266_tgt) = self."!cursor_start"() + rx266_cur."!cursor_debug"("START ", "quote_escape:sym") + .lex unicode:"$\x{a2}", rx266_cur .local pmc match .lex "$/", match - length rx267_eos, rx267_tgt - gt rx267_pos, rx267_eos, rx267_done - set rx267_off, 0 - lt rx267_pos, 2, rx267_start - sub rx267_off, rx267_pos, 1 - substr rx267_tgt, rx267_tgt, rx267_off - rx267_start: + length rx266_eos, rx266_tgt + gt rx266_pos, rx266_eos, rx266_done + set rx266_off, 0 + lt rx266_pos, 2, rx266_start + sub rx266_off, rx266_pos, 1 + substr rx266_tgt, rx266_tgt, rx266_off + rx266_start: $I10 = self.'from'() - ne $I10, -1, rxscan270_done - goto rxscan270_scan - rxscan270_loop: - ($P10) = rx267_cur."from"() + ne $I10, -1, rxscan269_done + goto rxscan269_scan + rxscan269_loop: + ($P10) = rx266_cur."from"() inc $P10 - set rx267_pos, $P10 - ge rx267_pos, rx267_eos, rxscan270_done - rxscan270_scan: - set_addr $I10, rxscan270_loop - rx267_cur."!mark_push"(0, rx267_pos, $I10) - rxscan270_done: -.annotate 'line', 96 - # rx literal "\\c" - add $I11, rx267_pos, 2 - gt $I11, rx267_eos, rx267_fail - sub $I11, rx267_pos, rx267_off - substr $S10, rx267_tgt, $I11, 2 - ne $S10, "\\c", rx267_fail - add rx267_pos, 2 + set rx266_pos, $P10 + ge rx266_pos, rx266_eos, rxscan269_done + rxscan269_scan: + set_addr $I10, rxscan269_loop + rx266_cur."!mark_push"(0, rx266_pos, $I10) + rxscan269_done: +.annotate 'line', 94 + # rx literal "\\o" + add $I11, rx266_pos, 2 + gt $I11, rx266_eos, rx266_fail + sub $I11, rx266_pos, rx266_off + substr $S10, rx266_tgt, $I11, 2 + ne $S10, "\\o", rx266_fail + add rx266_pos, 2 # rx subrule "quotemod_check" subtype=zerowidth negate= - rx267_cur."!cursor_pos"(rx267_pos) - $P10 = rx267_cur."quotemod_check"("b") - unless $P10, rx267_fail - # rx subrule "charspec" subtype=capture negate= - rx267_cur."!cursor_pos"(rx267_pos) - $P10 = rx267_cur."charspec"() - unless $P10, rx267_fail - rx267_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("charspec") - rx267_pos = $P10."pos"() + rx266_cur."!cursor_pos"(rx266_pos) + $P10 = rx266_cur."quotemod_check"("b") + unless $P10, rx266_fail + alt270_0: +.annotate 'line', 95 + set_addr $I10, alt270_1 + rx266_cur."!mark_push"(0, rx266_pos, $I10) + # rx subrule "octint" subtype=capture negate= + rx266_cur."!cursor_pos"(rx266_pos) + $P10 = rx266_cur."octint"() + unless $P10, rx266_fail + rx266_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("octint") + rx266_pos = $P10."pos"() + goto alt270_end + alt270_1: + # rx literal "[" + add $I11, rx266_pos, 1 + gt $I11, rx266_eos, rx266_fail + sub $I11, rx266_pos, rx266_off + substr $S10, rx266_tgt, $I11, 1 + ne $S10, "[", rx266_fail + add rx266_pos, 1 + # rx subrule "octints" subtype=capture negate= + rx266_cur."!cursor_pos"(rx266_pos) + $P10 = rx266_cur."octints"() + unless $P10, rx266_fail + rx266_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("octints") + rx266_pos = $P10."pos"() + # rx literal "]" + add $I11, rx266_pos, 1 + gt $I11, rx266_eos, rx266_fail + sub $I11, rx266_pos, rx266_off + substr $S10, rx266_tgt, $I11, 1 + ne $S10, "]", rx266_fail + add rx266_pos, 1 + alt270_end: +.annotate 'line', 93 # rx pass - rx267_cur."!cursor_pass"(rx267_pos, "quote_escape:sym") - rx267_cur."!cursor_debug"("PASS ", "quote_escape:sym", " at pos=", rx267_pos) - .return (rx267_cur) - rx267_fail: + rx266_cur."!cursor_pass"(rx266_pos, "quote_escape:sym") + rx266_cur."!cursor_debug"("PASS ", "quote_escape:sym", " at pos=", rx266_pos) + .return (rx266_cur) + rx266_fail: .annotate 'line', 33 - (rx267_rep, rx267_pos, $I10, $P10) = rx267_cur."!mark_fail"(0) - lt rx267_pos, -1, rx267_done - eq rx267_pos, -1, rx267_fail + (rx266_rep, rx266_pos, $I10, $P10) = rx266_cur."!mark_fail"(0) + lt rx266_pos, -1, rx266_done + eq rx266_pos, -1, rx266_fail jump $I10 - rx267_done: - rx267_cur."!cursor_fail"() - rx267_cur."!cursor_debug"("FAIL ", "quote_escape:sym") - .return (rx267_cur) + rx266_done: + rx266_cur."!cursor_fail"() + rx266_cur."!cursor_debug"("FAIL ", "quote_escape:sym") + .return (rx266_cur) .return () .end .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_escape:sym" :subid("88_1275511685.92888") :method +.sub "!PREFIX__quote_escape:sym" :subid("88_1275599990.60173") :method .annotate 'line', 33 - new $P269, "ResizablePMCArray" - push $P269, "\\c" - .return ($P269) + new $P268, "ResizablePMCArray" + push $P268, "\\o" + .return ($P268) .end .namespace ["HLL";"Grammar"] -.sub "quote_escape:sym<0>" :subid("89_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_escape:sym" :subid("89_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 .local string rx272_tgt .local int rx272_pos @@ -3979,7 +3974,7 @@ An operator precedence parser. .local int rx272_rep .local pmc rx272_cur (rx272_cur, rx272_pos, rx272_tgt) = self."!cursor_start"() - rx272_cur."!cursor_debug"("START ", "quote_escape:sym<0>") + rx272_cur."!cursor_debug"("START ", "quote_escape:sym") .lex unicode:"$\x{a2}", rx272_cur .local pmc match .lex "$/", match @@ -4003,41 +3998,27 @@ An operator precedence parser. rx272_cur."!mark_push"(0, rx272_pos, $I10) rxscan275_done: .annotate 'line', 97 - # rx literal "\\" - add $I11, rx272_pos, 1 - gt $I11, rx272_eos, rx272_fail - sub $I11, rx272_pos, rx272_off - substr $S10, rx272_tgt, $I11, 1 - ne $S10, "\\", rx272_fail - add rx272_pos, 1 - # rx subcapture "sym" - set_addr $I10, rxcap_276_fail - rx272_cur."!mark_push"(0, rx272_pos, $I10) - # rx literal "0" - add $I11, rx272_pos, 1 + # rx literal "\\c" + add $I11, rx272_pos, 2 gt $I11, rx272_eos, rx272_fail sub $I11, rx272_pos, rx272_off - substr $S10, rx272_tgt, $I11, 1 - ne $S10, "0", rx272_fail - add rx272_pos, 1 - set_addr $I10, rxcap_276_fail - ($I12, $I11) = rx272_cur."!mark_peek"($I10) - rx272_cur."!cursor_pos"($I11) - ($P10) = rx272_cur."!cursor_start"() - $P10."!cursor_pass"(rx272_pos, "") - rx272_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("sym") - goto rxcap_276_done - rxcap_276_fail: - goto rx272_fail - rxcap_276_done: + substr $S10, rx272_tgt, $I11, 2 + ne $S10, "\\c", rx272_fail + add rx272_pos, 2 # rx subrule "quotemod_check" subtype=zerowidth negate= rx272_cur."!cursor_pos"(rx272_pos) $P10 = rx272_cur."quotemod_check"("b") unless $P10, rx272_fail + # rx subrule "charspec" subtype=capture negate= + rx272_cur."!cursor_pos"(rx272_pos) + $P10 = rx272_cur."charspec"() + unless $P10, rx272_fail + rx272_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("charspec") + rx272_pos = $P10."pos"() # rx pass - rx272_cur."!cursor_pass"(rx272_pos, "quote_escape:sym<0>") - rx272_cur."!cursor_debug"("PASS ", "quote_escape:sym<0>", " at pos=", rx272_pos) + rx272_cur."!cursor_pass"(rx272_pos, "quote_escape:sym") + rx272_cur."!cursor_debug"("PASS ", "quote_escape:sym", " at pos=", rx272_pos) .return (rx272_cur) rx272_fail: .annotate 'line', 33 @@ -4047,781 +4028,874 @@ An operator precedence parser. jump $I10 rx272_done: rx272_cur."!cursor_fail"() - rx272_cur."!cursor_debug"("FAIL ", "quote_escape:sym<0>") + rx272_cur."!cursor_debug"("FAIL ", "quote_escape:sym") .return (rx272_cur) .return () .end .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_escape:sym<0>" :subid("90_1275511685.92888") :method +.sub "!PREFIX__quote_escape:sym" :subid("90_1275599990.60173") :method .annotate 'line', 33 new $P274, "ResizablePMCArray" - push $P274, "\\0" + push $P274, "\\c" .return ($P274) .end .namespace ["HLL";"Grammar"] -.sub "quote_escape:sym" :subid("91_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "quote_escape:sym<0>" :subid("91_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 - .const 'Sub' $P297 = "95_1275511685.92888" - capture_lex $P297 - .const 'Sub' $P290 = "94_1275511685.92888" - capture_lex $P290 - .const 'Sub' $P285 = "93_1275511685.92888" - capture_lex $P285 - .local string rx278_tgt - .local int rx278_pos - .local int rx278_off - .local int rx278_eos - .local int rx278_rep - .local pmc rx278_cur - (rx278_cur, rx278_pos, rx278_tgt) = self."!cursor_start"() - rx278_cur."!cursor_debug"("START ", "quote_escape:sym") - .lex unicode:"$\x{a2}", rx278_cur + .local string rx277_tgt + .local int rx277_pos + .local int rx277_off + .local int rx277_eos + .local int rx277_rep + .local pmc rx277_cur + (rx277_cur, rx277_pos, rx277_tgt) = self."!cursor_start"() + rx277_cur."!cursor_debug"("START ", "quote_escape:sym<0>") + .lex unicode:"$\x{a2}", rx277_cur .local pmc match .lex "$/", match - length rx278_eos, rx278_tgt - gt rx278_pos, rx278_eos, rx278_done - set rx278_off, 0 - lt rx278_pos, 2, rx278_start - sub rx278_off, rx278_pos, 1 - substr rx278_tgt, rx278_tgt, rx278_off - rx278_start: + length rx277_eos, rx277_tgt + gt rx277_pos, rx277_eos, rx277_done + set rx277_off, 0 + lt rx277_pos, 2, rx277_start + sub rx277_off, rx277_pos, 1 + substr rx277_tgt, rx277_tgt, rx277_off + rx277_start: $I10 = self.'from'() - ne $I10, -1, rxscan281_done - goto rxscan281_scan - rxscan281_loop: - ($P10) = rx278_cur."from"() + ne $I10, -1, rxscan280_done + goto rxscan280_scan + rxscan280_loop: + ($P10) = rx277_cur."from"() inc $P10 - set rx278_pos, $P10 - ge rx278_pos, rx278_eos, rxscan281_done - rxscan281_scan: - set_addr $I10, rxscan281_loop - rx278_cur."!mark_push"(0, rx278_pos, $I10) - rxscan281_done: -.annotate 'line', 99 - rx278_cur."!cursor_pos"(rx278_pos) - find_lex $P282, unicode:"$\x{a2}" - $P283 = $P282."MATCH"() - store_lex "$/", $P283 - .const 'Sub' $P285 = "93_1275511685.92888" - capture_lex $P285 - $P286 = $P285() + set rx277_pos, $P10 + ge rx277_pos, rx277_eos, rxscan280_done + rxscan280_scan: + set_addr $I10, rxscan280_loop + rx277_cur."!mark_push"(0, rx277_pos, $I10) + rxscan280_done: +.annotate 'line', 98 # rx literal "\\" - add $I11, rx278_pos, 1 - gt $I11, rx278_eos, rx278_fail - sub $I11, rx278_pos, rx278_off - substr $S10, rx278_tgt, $I11, 1 - ne $S10, "\\", rx278_fail - add rx278_pos, 1 - alt287_0: + add $I11, rx277_pos, 1 + gt $I11, rx277_eos, rx277_fail + sub $I11, rx277_pos, rx277_off + substr $S10, rx277_tgt, $I11, 1 + ne $S10, "\\", rx277_fail + add rx277_pos, 1 + # rx subcapture "sym" + set_addr $I10, rxcap_281_fail + rx277_cur."!mark_push"(0, rx277_pos, $I10) + # rx literal "0" + add $I11, rx277_pos, 1 + gt $I11, rx277_eos, rx277_fail + sub $I11, rx277_pos, rx277_off + substr $S10, rx277_tgt, $I11, 1 + ne $S10, "0", rx277_fail + add rx277_pos, 1 + set_addr $I10, rxcap_281_fail + ($I12, $I11) = rx277_cur."!mark_peek"($I10) + rx277_cur."!cursor_pos"($I11) + ($P10) = rx277_cur."!cursor_start"() + $P10."!cursor_pass"(rx277_pos, "") + rx277_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("sym") + goto rxcap_281_done + rxcap_281_fail: + goto rx277_fail + rxcap_281_done: + # rx subrule "quotemod_check" subtype=zerowidth negate= + rx277_cur."!cursor_pos"(rx277_pos) + $P10 = rx277_cur."quotemod_check"("b") + unless $P10, rx277_fail + # rx pass + rx277_cur."!cursor_pass"(rx277_pos, "quote_escape:sym<0>") + rx277_cur."!cursor_debug"("PASS ", "quote_escape:sym<0>", " at pos=", rx277_pos) + .return (rx277_cur) + rx277_fail: +.annotate 'line', 33 + (rx277_rep, rx277_pos, $I10, $P10) = rx277_cur."!mark_fail"(0) + lt rx277_pos, -1, rx277_done + eq rx277_pos, -1, rx277_fail + jump $I10 + rx277_done: + rx277_cur."!cursor_fail"() + rx277_cur."!cursor_debug"("FAIL ", "quote_escape:sym<0>") + .return (rx277_cur) + .return () +.end + + +.namespace ["HLL";"Grammar"] +.sub "!PREFIX__quote_escape:sym<0>" :subid("92_1275599990.60173") :method +.annotate 'line', 33 + new $P279, "ResizablePMCArray" + push $P279, "\\0" + .return ($P279) +.end + + +.namespace ["HLL";"Grammar"] +.sub "quote_escape:sym" :subid("93_1275599990.60173") :method :outer("11_1275599990.60173") +.annotate 'line', 33 + .const 'Sub' $P302 = "97_1275599990.60173" + capture_lex $P302 + .const 'Sub' $P295 = "96_1275599990.60173" + capture_lex $P295 + .const 'Sub' $P290 = "95_1275599990.60173" + capture_lex $P290 + .local string rx283_tgt + .local int rx283_pos + .local int rx283_off + .local int rx283_eos + .local int rx283_rep + .local pmc rx283_cur + (rx283_cur, rx283_pos, rx283_tgt) = self."!cursor_start"() + rx283_cur."!cursor_debug"("START ", "quote_escape:sym") + .lex unicode:"$\x{a2}", rx283_cur + .local pmc match + .lex "$/", match + length rx283_eos, rx283_tgt + gt rx283_pos, rx283_eos, rx283_done + set rx283_off, 0 + lt rx283_pos, 2, rx283_start + sub rx283_off, rx283_pos, 1 + substr rx283_tgt, rx283_tgt, rx283_off + rx283_start: + $I10 = self.'from'() + ne $I10, -1, rxscan286_done + goto rxscan286_scan + rxscan286_loop: + ($P10) = rx283_cur."from"() + inc $P10 + set rx283_pos, $P10 + ge rx283_pos, rx283_eos, rxscan286_done + rxscan286_scan: + set_addr $I10, rxscan286_loop + rx283_cur."!mark_push"(0, rx283_pos, $I10) + rxscan286_done: .annotate 'line', 100 - set_addr $I10, alt287_1 - rx278_cur."!mark_push"(0, rx278_pos, $I10) + rx283_cur."!cursor_pos"(rx283_pos) + find_lex $P287, unicode:"$\x{a2}" + $P288 = $P287."MATCH"() + store_lex "$/", $P288 + .const 'Sub' $P290 = "95_1275599990.60173" + capture_lex $P290 + $P291 = $P290() + # rx literal "\\" + add $I11, rx283_pos, 1 + gt $I11, rx283_eos, rx283_fail + sub $I11, rx283_pos, rx283_off + substr $S10, rx283_tgt, $I11, 1 + ne $S10, "\\", rx283_fail + add rx283_pos, 1 + alt292_0: .annotate 'line', 101 - # rx subrule "quotemod_check" subtype=zerowidth negate= - rx278_cur."!cursor_pos"(rx278_pos) - $P10 = rx278_cur."quotemod_check"("b") - unless $P10, rx278_fail - alt288_0: + set_addr $I10, alt292_1 + rx283_cur."!mark_push"(0, rx283_pos, $I10) .annotate 'line', 102 - set_addr $I10, alt288_1 - rx278_cur."!mark_push"(0, rx278_pos, $I10) + # rx subrule "quotemod_check" subtype=zerowidth negate= + rx283_cur."!cursor_pos"(rx283_pos) + $P10 = rx283_cur."quotemod_check"("b") + unless $P10, rx283_fail + alt293_0: .annotate 'line', 103 - # rx subrule $P290 subtype=capture negate= - rx278_cur."!cursor_pos"(rx278_pos) - .const 'Sub' $P290 = "94_1275511685.92888" - capture_lex $P290 - $P10 = rx278_cur.$P290() - unless $P10, rx278_fail - rx278_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("textqq") - rx278_pos = $P10."pos"() - goto alt288_end - alt288_1: + set_addr $I10, alt293_1 + rx283_cur."!mark_push"(0, rx283_pos, $I10) .annotate 'line', 104 + # rx subrule $P295 subtype=capture negate= + rx283_cur."!cursor_pos"(rx283_pos) + .const 'Sub' $P295 = "96_1275599990.60173" + capture_lex $P295 + $P10 = rx283_cur.$P295() + unless $P10, rx283_fail + rx283_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("textqq") + rx283_pos = $P10."pos"() + goto alt293_end + alt293_1: +.annotate 'line', 105 # rx subcapture "x" - set_addr $I10, rxcap_293_fail - rx278_cur."!mark_push"(0, rx278_pos, $I10) + set_addr $I10, rxcap_298_fail + rx283_cur."!mark_push"(0, rx283_pos, $I10) # rx charclass w - ge rx278_pos, rx278_eos, rx278_fail - sub $I10, rx278_pos, rx278_off - is_cclass $I11, 8192, rx278_tgt, $I10 - unless $I11, rx278_fail - inc rx278_pos - set_addr $I10, rxcap_293_fail - ($I12, $I11) = rx278_cur."!mark_peek"($I10) - rx278_cur."!cursor_pos"($I11) - ($P10) = rx278_cur."!cursor_start"() - $P10."!cursor_pass"(rx278_pos, "") - rx278_cur."!mark_push"(0, -1, 0, $P10) + ge rx283_pos, rx283_eos, rx283_fail + sub $I10, rx283_pos, rx283_off + is_cclass $I11, 8192, rx283_tgt, $I10 + unless $I11, rx283_fail + inc rx283_pos + set_addr $I10, rxcap_298_fail + ($I12, $I11) = rx283_cur."!mark_peek"($I10) + rx283_cur."!cursor_pos"($I11) + ($P10) = rx283_cur."!cursor_start"() + $P10."!cursor_pass"(rx283_pos, "") + rx283_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("x") - goto rxcap_293_done - rxcap_293_fail: - goto rx278_fail - rxcap_293_done: - rx278_cur."!cursor_pos"(rx278_pos) - find_lex $P294, unicode:"$\x{a2}" - $P295 = $P294."MATCH"() - store_lex "$/", $P295 - .const 'Sub' $P297 = "95_1275511685.92888" - capture_lex $P297 - $P307 = $P297() - alt288_end: -.annotate 'line', 101 - goto alt287_end - alt287_1: -.annotate 'line', 106 + goto rxcap_298_done + rxcap_298_fail: + goto rx283_fail + rxcap_298_done: + rx283_cur."!cursor_pos"(rx283_pos) + find_lex $P299, unicode:"$\x{a2}" + $P300 = $P299."MATCH"() + store_lex "$/", $P300 + .const 'Sub' $P302 = "97_1275599990.60173" + capture_lex $P302 + $P312 = $P302() + alt293_end: +.annotate 'line', 102 + goto alt292_end + alt292_1: +.annotate 'line', 107 # rx subcapture "textq" - set_addr $I10, rxcap_308_fail - rx278_cur."!mark_push"(0, rx278_pos, $I10) + set_addr $I10, rxcap_313_fail + rx283_cur."!mark_push"(0, rx283_pos, $I10) # rx charclass . - ge rx278_pos, rx278_eos, rx278_fail - inc rx278_pos - set_addr $I10, rxcap_308_fail - ($I12, $I11) = rx278_cur."!mark_peek"($I10) - rx278_cur."!cursor_pos"($I11) - ($P10) = rx278_cur."!cursor_start"() - $P10."!cursor_pass"(rx278_pos, "") - rx278_cur."!mark_push"(0, -1, 0, $P10) + ge rx283_pos, rx283_eos, rx283_fail + inc rx283_pos + set_addr $I10, rxcap_313_fail + ($I12, $I11) = rx283_cur."!mark_peek"($I10) + rx283_cur."!cursor_pos"($I11) + ($P10) = rx283_cur."!cursor_start"() + $P10."!cursor_pass"(rx283_pos, "") + rx283_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("textq") - goto rxcap_308_done - rxcap_308_fail: - goto rx278_fail - rxcap_308_done: - alt287_end: -.annotate 'line', 98 + goto rxcap_313_done + rxcap_313_fail: + goto rx283_fail + rxcap_313_done: + alt292_end: +.annotate 'line', 99 # rx pass - rx278_cur."!cursor_pass"(rx278_pos, "quote_escape:sym") - rx278_cur."!cursor_debug"("PASS ", "quote_escape:sym", " at pos=", rx278_pos) - .return (rx278_cur) - rx278_fail: + rx283_cur."!cursor_pass"(rx283_pos, "quote_escape:sym") + rx283_cur."!cursor_debug"("PASS ", "quote_escape:sym", " at pos=", rx283_pos) + .return (rx283_cur) + rx283_fail: .annotate 'line', 33 - (rx278_rep, rx278_pos, $I10, $P10) = rx278_cur."!mark_fail"(0) - lt rx278_pos, -1, rx278_done - eq rx278_pos, -1, rx278_fail + (rx283_rep, rx283_pos, $I10, $P10) = rx283_cur."!mark_fail"(0) + lt rx283_pos, -1, rx283_done + eq rx283_pos, -1, rx283_fail jump $I10 - rx278_done: - rx278_cur."!cursor_fail"() - rx278_cur."!cursor_debug"("FAIL ", "quote_escape:sym") - .return (rx278_cur) + rx283_done: + rx283_cur."!cursor_fail"() + rx283_cur."!cursor_debug"("FAIL ", "quote_escape:sym") + .return (rx283_cur) .return () .end .namespace ["HLL";"Grammar"] -.sub "!PREFIX__quote_escape:sym" :subid("92_1275511685.92888") :method +.sub "!PREFIX__quote_escape:sym" :subid("94_1275599990.60173") :method .annotate 'line', 33 - new $P280, "ResizablePMCArray" - push $P280, "" - .return ($P280) + new $P285, "ResizablePMCArray" + push $P285, "" + .return ($P285) .end .namespace ["HLL";"Grammar"] -.sub "_block284" :anon :subid("93_1275511685.92888") :outer("91_1275511685.92888") -.annotate 'line', 99 +.sub "_block289" :anon :subid("95_1275599990.60173") :outer("93_1275599990.60173") +.annotate 'line', 100 .return () .end .namespace ["HLL";"Grammar"] -.sub "_block289" :anon :subid("94_1275511685.92888") :method :outer("91_1275511685.92888") -.annotate 'line', 103 - .local string rx291_tgt - .local int rx291_pos - .local int rx291_off - .local int rx291_eos - .local int rx291_rep - .local pmc rx291_cur - (rx291_cur, rx291_pos, rx291_tgt) = self."!cursor_start"() - rx291_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx291_cur +.sub "_block294" :anon :subid("96_1275599990.60173") :method :outer("93_1275599990.60173") +.annotate 'line', 104 + .local string rx296_tgt + .local int rx296_pos + .local int rx296_off + .local int rx296_eos + .local int rx296_rep + .local pmc rx296_cur + (rx296_cur, rx296_pos, rx296_tgt) = self."!cursor_start"() + rx296_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx296_cur .local pmc match .lex "$/", match - length rx291_eos, rx291_tgt - gt rx291_pos, rx291_eos, rx291_done - set rx291_off, 0 - lt rx291_pos, 2, rx291_start - sub rx291_off, rx291_pos, 1 - substr rx291_tgt, rx291_tgt, rx291_off - rx291_start: + length rx296_eos, rx296_tgt + gt rx296_pos, rx296_eos, rx296_done + set rx296_off, 0 + lt rx296_pos, 2, rx296_start + sub rx296_off, rx296_pos, 1 + substr rx296_tgt, rx296_tgt, rx296_off + rx296_start: $I10 = self.'from'() - ne $I10, -1, rxscan292_done - goto rxscan292_scan - rxscan292_loop: - ($P10) = rx291_cur."from"() + ne $I10, -1, rxscan297_done + goto rxscan297_scan + rxscan297_loop: + ($P10) = rx296_cur."from"() inc $P10 - set rx291_pos, $P10 - ge rx291_pos, rx291_eos, rxscan292_done - rxscan292_scan: - set_addr $I10, rxscan292_loop - rx291_cur."!mark_push"(0, rx291_pos, $I10) - rxscan292_done: + set rx296_pos, $P10 + ge rx296_pos, rx296_eos, rxscan297_done + rxscan297_scan: + set_addr $I10, rxscan297_loop + rx296_cur."!mark_push"(0, rx296_pos, $I10) + rxscan297_done: # rx charclass W - ge rx291_pos, rx291_eos, rx291_fail - sub $I10, rx291_pos, rx291_off - is_cclass $I11, 8192, rx291_tgt, $I10 - if $I11, rx291_fail - inc rx291_pos + ge rx296_pos, rx296_eos, rx296_fail + sub $I10, rx296_pos, rx296_off + is_cclass $I11, 8192, rx296_tgt, $I10 + if $I11, rx296_fail + inc rx296_pos # rx pass - rx291_cur."!cursor_pass"(rx291_pos, "") - rx291_cur."!cursor_debug"("PASS ", "", " at pos=", rx291_pos) - .return (rx291_cur) - rx291_fail: - (rx291_rep, rx291_pos, $I10, $P10) = rx291_cur."!mark_fail"(0) - lt rx291_pos, -1, rx291_done - eq rx291_pos, -1, rx291_fail + rx296_cur."!cursor_pass"(rx296_pos, "") + rx296_cur."!cursor_debug"("PASS ", "", " at pos=", rx296_pos) + .return (rx296_cur) + rx296_fail: + (rx296_rep, rx296_pos, $I10, $P10) = rx296_cur."!mark_fail"(0) + lt rx296_pos, -1, rx296_done + eq rx296_pos, -1, rx296_fail jump $I10 - rx291_done: - rx291_cur."!cursor_fail"() - rx291_cur."!cursor_debug"("FAIL ", "") - .return (rx291_cur) + rx296_done: + rx296_cur."!cursor_fail"() + rx296_cur."!cursor_debug"("FAIL ", "") + .return (rx296_cur) .return () .end .namespace ["HLL";"Grammar"] -.sub "_block296" :anon :subid("95_1275511685.92888") :outer("91_1275511685.92888") -.annotate 'line', 104 - find_lex $P298, "$/" - $P299 = $P298."CURSOR"() - new $P300, "String" - assign $P300, "Unrecognized backslash sequence: '\\" - find_lex $P301, "$/" - unless_null $P301, vivify_106 - $P301 = root_new ['parrot';'Hash'] - vivify_106: - set $P302, $P301["x"] - unless_null $P302, vivify_107 - new $P302, "Undef" - vivify_107: - $S303 = $P302."Str"() - concat $P304, $P300, $S303 - concat $P305, $P304, "'" - $P306 = $P299."panic"($P305) - .return ($P306) +.sub "_block301" :anon :subid("97_1275599990.60173") :outer("93_1275599990.60173") +.annotate 'line', 105 + find_lex $P303, "$/" + $P304 = $P303."CURSOR"() + new $P305, "String" + assign $P305, "Unrecognized backslash sequence: '\\" + find_lex $P306, "$/" + unless_null $P306, vivify_108 + $P306 = root_new ['parrot';'Hash'] + vivify_108: + set $P307, $P306["x"] + unless_null $P307, vivify_109 + new $P307, "Undef" + vivify_109: + $S308 = $P307."Str"() + concat $P309, $P305, $S308 + concat $P310, $P309, "'" + $P311 = $P304."panic"($P310) + .return ($P311) .end .namespace ["HLL";"Grammar"] -.sub "charname" :subid("96_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "charname" :subid("98_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 - .const 'Sub' $P319 = "98_1275511685.92888" - capture_lex $P319 - .local string rx310_tgt - .local int rx310_pos - .local int rx310_off - .local int rx310_eos - .local int rx310_rep - .local pmc rx310_cur - (rx310_cur, rx310_pos, rx310_tgt) = self."!cursor_start"() - rx310_cur."!cursor_debug"("START ", "charname") - .lex unicode:"$\x{a2}", rx310_cur + .const 'Sub' $P324 = "100_1275599990.60173" + capture_lex $P324 + .local string rx315_tgt + .local int rx315_pos + .local int rx315_off + .local int rx315_eos + .local int rx315_rep + .local pmc rx315_cur + (rx315_cur, rx315_pos, rx315_tgt) = self."!cursor_start"() + rx315_cur."!cursor_debug"("START ", "charname") + .lex unicode:"$\x{a2}", rx315_cur .local pmc match .lex "$/", match - length rx310_eos, rx310_tgt - gt rx310_pos, rx310_eos, rx310_done - set rx310_off, 0 - lt rx310_pos, 2, rx310_start - sub rx310_off, rx310_pos, 1 - substr rx310_tgt, rx310_tgt, rx310_off - rx310_start: + length rx315_eos, rx315_tgt + gt rx315_pos, rx315_eos, rx315_done + set rx315_off, 0 + lt rx315_pos, 2, rx315_start + sub rx315_off, rx315_pos, 1 + substr rx315_tgt, rx315_tgt, rx315_off + rx315_start: $I10 = self.'from'() - ne $I10, -1, rxscan314_done - goto rxscan314_scan - rxscan314_loop: - ($P10) = rx310_cur."from"() + ne $I10, -1, rxscan319_done + goto rxscan319_scan + rxscan319_loop: + ($P10) = rx315_cur."from"() inc $P10 - set rx310_pos, $P10 - ge rx310_pos, rx310_eos, rxscan314_done - rxscan314_scan: - set_addr $I10, rxscan314_loop - rx310_cur."!mark_push"(0, rx310_pos, $I10) - rxscan314_done: - alt315_0: -.annotate 'line', 110 - set_addr $I10, alt315_1 - rx310_cur."!mark_push"(0, rx310_pos, $I10) + set rx315_pos, $P10 + ge rx315_pos, rx315_eos, rxscan319_done + rxscan319_scan: + set_addr $I10, rxscan319_loop + rx315_cur."!mark_push"(0, rx315_pos, $I10) + rxscan319_done: + alt320_0: .annotate 'line', 111 + set_addr $I10, alt320_1 + rx315_cur."!mark_push"(0, rx315_pos, $I10) +.annotate 'line', 112 # rx subrule "integer" subtype=capture negate= - rx310_cur."!cursor_pos"(rx310_pos) - $P10 = rx310_cur."integer"() - unless $P10, rx310_fail - rx310_cur."!mark_push"(0, -1, 0, $P10) + rx315_cur."!cursor_pos"(rx315_pos) + $P10 = rx315_cur."integer"() + unless $P10, rx315_fail + rx315_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("integer") - rx310_pos = $P10."pos"() - goto alt315_end - alt315_1: -.annotate 'line', 112 + rx315_pos = $P10."pos"() + goto alt320_end + alt320_1: +.annotate 'line', 113 # rx enumcharlist negate=0 - ge rx310_pos, rx310_eos, rx310_fail - sub $I10, rx310_pos, rx310_off - substr $S10, rx310_tgt, $I10, 1 + ge rx315_pos, rx315_eos, rx315_fail + sub $I10, rx315_pos, rx315_off + substr $S10, rx315_tgt, $I10, 1 index $I11, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", $S10 - lt $I11, 0, rx310_fail - inc rx310_pos - # rx rxquantf316 ** 0..* - set_addr $I10, rxquantf316_loop - rx310_cur."!mark_push"(0, rx310_pos, $I10) - goto rxquantf316_done - rxquantf316_loop: + lt $I11, 0, rx315_fail + inc rx315_pos + # rx rxquantf321 ** 0..* + set_addr $I10, rxquantf321_loop + rx315_cur."!mark_push"(0, rx315_pos, $I10) + goto rxquantf321_done + rxquantf321_loop: # rx enumcharlist negate=1 - ge rx310_pos, rx310_eos, rx310_fail - sub $I10, rx310_pos, rx310_off - substr $S10, rx310_tgt, $I10, 1 + ge rx315_pos, rx315_eos, rx315_fail + sub $I10, rx315_pos, rx315_off + substr $S10, rx315_tgt, $I10, 1 index $I11, "],#", $S10 - ge $I11, 0, rx310_fail - inc rx310_pos - set_addr $I10, rxquantf316_loop - rx310_cur."!mark_push"($I317, rx310_pos, $I10) - rxquantf316_done: + ge $I11, 0, rx315_fail + inc rx315_pos + set_addr $I10, rxquantf321_loop + rx315_cur."!mark_push"($I322, rx315_pos, $I10) + rxquantf321_done: # rx enumcharlist negate=0 - ge rx310_pos, rx310_eos, rx310_fail - sub $I10, rx310_pos, rx310_off - substr $S10, rx310_tgt, $I10, 1 + ge rx315_pos, rx315_eos, rx315_fail + sub $I10, rx315_pos, rx315_off + substr $S10, rx315_tgt, $I10, 1 index $I11, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ)", $S10 - lt $I11, 0, rx310_fail - inc rx310_pos -.annotate 'line', 113 + lt $I11, 0, rx315_fail + inc rx315_pos +.annotate 'line', 114 # rx subrule "before" subtype=zerowidth negate= - rx310_cur."!cursor_pos"(rx310_pos) - .const 'Sub' $P319 = "98_1275511685.92888" - capture_lex $P319 - $P10 = rx310_cur."before"($P319) - unless $P10, rx310_fail - alt315_end: -.annotate 'line', 110 + rx315_cur."!cursor_pos"(rx315_pos) + .const 'Sub' $P324 = "100_1275599990.60173" + capture_lex $P324 + $P10 = rx315_cur."before"($P324) + unless $P10, rx315_fail + alt320_end: +.annotate 'line', 111 # rx pass - rx310_cur."!cursor_pass"(rx310_pos, "charname") - rx310_cur."!cursor_debug"("PASS ", "charname", " at pos=", rx310_pos) - .return (rx310_cur) - rx310_fail: + rx315_cur."!cursor_pass"(rx315_pos, "charname") + rx315_cur."!cursor_debug"("PASS ", "charname", " at pos=", rx315_pos) + .return (rx315_cur) + rx315_fail: .annotate 'line', 33 - (rx310_rep, rx310_pos, $I10, $P10) = rx310_cur."!mark_fail"(0) - lt rx310_pos, -1, rx310_done - eq rx310_pos, -1, rx310_fail + (rx315_rep, rx315_pos, $I10, $P10) = rx315_cur."!mark_fail"(0) + lt rx315_pos, -1, rx315_done + eq rx315_pos, -1, rx315_fail jump $I10 - rx310_done: - rx310_cur."!cursor_fail"() - rx310_cur."!cursor_debug"("FAIL ", "charname") - .return (rx310_cur) + rx315_done: + rx315_cur."!cursor_fail"() + rx315_cur."!cursor_debug"("FAIL ", "charname") + .return (rx315_cur) .return () .end .namespace ["HLL";"Grammar"] -.sub "!PREFIX__charname" :subid("97_1275511685.92888") :method +.sub "!PREFIX__charname" :subid("99_1275599990.60173") :method .annotate 'line', 33 - $P312 = self."!PREFIX__!subrule"("integer", "") - new $P313, "ResizablePMCArray" - push $P313, "Z" - push $P313, "Y" - push $P313, "X" - push $P313, "W" - push $P313, "V" - push $P313, "U" - push $P313, "T" - push $P313, "S" - push $P313, "R" - push $P313, "Q" - push $P313, "P" - push $P313, "O" - push $P313, "N" - push $P313, "M" - push $P313, "L" - push $P313, "K" - push $P313, "J" - push $P313, "I" - push $P313, "H" - push $P313, "G" - push $P313, "F" - push $P313, "E" - push $P313, "D" - push $P313, "C" - push $P313, "B" - push $P313, "A" - push $P313, "z" - push $P313, "y" - push $P313, "x" - push $P313, "w" - push $P313, "v" - push $P313, "u" - push $P313, "t" - push $P313, "s" - push $P313, "r" - push $P313, "q" - push $P313, "p" - push $P313, "o" - push $P313, "n" - push $P313, "m" - push $P313, "l" - push $P313, "k" - push $P313, "j" - push $P313, "i" - push $P313, "h" - push $P313, "g" - push $P313, "f" - push $P313, "e" - push $P313, "d" - push $P313, "c" - push $P313, "b" - push $P313, "a" - push $P313, $P312 - .return ($P313) + $P317 = self."!PREFIX__!subrule"("integer", "") + new $P318, "ResizablePMCArray" + push $P318, "Z" + push $P318, "Y" + push $P318, "X" + push $P318, "W" + push $P318, "V" + push $P318, "U" + push $P318, "T" + push $P318, "S" + push $P318, "R" + push $P318, "Q" + push $P318, "P" + push $P318, "O" + push $P318, "N" + push $P318, "M" + push $P318, "L" + push $P318, "K" + push $P318, "J" + push $P318, "I" + push $P318, "H" + push $P318, "G" + push $P318, "F" + push $P318, "E" + push $P318, "D" + push $P318, "C" + push $P318, "B" + push $P318, "A" + push $P318, "z" + push $P318, "y" + push $P318, "x" + push $P318, "w" + push $P318, "v" + push $P318, "u" + push $P318, "t" + push $P318, "s" + push $P318, "r" + push $P318, "q" + push $P318, "p" + push $P318, "o" + push $P318, "n" + push $P318, "m" + push $P318, "l" + push $P318, "k" + push $P318, "j" + push $P318, "i" + push $P318, "h" + push $P318, "g" + push $P318, "f" + push $P318, "e" + push $P318, "d" + push $P318, "c" + push $P318, "b" + push $P318, "a" + push $P318, $P317 + .return ($P318) .end .namespace ["HLL";"Grammar"] -.sub "_block318" :anon :subid("98_1275511685.92888") :method :outer("96_1275511685.92888") -.annotate 'line', 113 - .local string rx320_tgt - .local int rx320_pos - .local int rx320_off - .local int rx320_eos - .local int rx320_rep - .local pmc rx320_cur - (rx320_cur, rx320_pos, rx320_tgt) = self."!cursor_start"() - rx320_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx320_cur +.sub "_block323" :anon :subid("100_1275599990.60173") :method :outer("98_1275599990.60173") +.annotate 'line', 114 + .local string rx325_tgt + .local int rx325_pos + .local int rx325_off + .local int rx325_eos + .local int rx325_rep + .local pmc rx325_cur + (rx325_cur, rx325_pos, rx325_tgt) = self."!cursor_start"() + rx325_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx325_cur .local pmc match .lex "$/", match - length rx320_eos, rx320_tgt - gt rx320_pos, rx320_eos, rx320_done - set rx320_off, 0 - lt rx320_pos, 2, rx320_start - sub rx320_off, rx320_pos, 1 - substr rx320_tgt, rx320_tgt, rx320_off - rx320_start: + length rx325_eos, rx325_tgt + gt rx325_pos, rx325_eos, rx325_done + set rx325_off, 0 + lt rx325_pos, 2, rx325_start + sub rx325_off, rx325_pos, 1 + substr rx325_tgt, rx325_tgt, rx325_off + rx325_start: $I10 = self.'from'() - ne $I10, -1, rxscan321_done - goto rxscan321_scan - rxscan321_loop: - ($P10) = rx320_cur."from"() + ne $I10, -1, rxscan326_done + goto rxscan326_scan + rxscan326_loop: + ($P10) = rx325_cur."from"() inc $P10 - set rx320_pos, $P10 - ge rx320_pos, rx320_eos, rxscan321_done - rxscan321_scan: - set_addr $I10, rxscan321_loop - rx320_cur."!mark_push"(0, rx320_pos, $I10) - rxscan321_done: + set rx325_pos, $P10 + ge rx325_pos, rx325_eos, rxscan326_done + rxscan326_scan: + set_addr $I10, rxscan326_loop + rx325_cur."!mark_push"(0, rx325_pos, $I10) + rxscan326_done: # rx charclass_q s r 0..-1 - sub $I10, rx320_pos, rx320_off - find_not_cclass $I11, 32, rx320_tgt, $I10, rx320_eos - add rx320_pos, rx320_off, $I11 + sub $I10, rx325_pos, rx325_off + find_not_cclass $I11, 32, rx325_tgt, $I10, rx325_eos + add rx325_pos, rx325_off, $I11 # rx enumcharlist negate=0 - ge rx320_pos, rx320_eos, rx320_fail - sub $I10, rx320_pos, rx320_off - substr $S10, rx320_tgt, $I10, 1 + ge rx325_pos, rx325_eos, rx325_fail + sub $I10, rx325_pos, rx325_off + substr $S10, rx325_tgt, $I10, 1 index $I11, "],#", $S10 - lt $I11, 0, rx320_fail - inc rx320_pos + lt $I11, 0, rx325_fail + inc rx325_pos # rx pass - rx320_cur."!cursor_pass"(rx320_pos, "") - rx320_cur."!cursor_debug"("PASS ", "", " at pos=", rx320_pos) - .return (rx320_cur) - rx320_fail: - (rx320_rep, rx320_pos, $I10, $P10) = rx320_cur."!mark_fail"(0) - lt rx320_pos, -1, rx320_done - eq rx320_pos, -1, rx320_fail + rx325_cur."!cursor_pass"(rx325_pos, "") + rx325_cur."!cursor_debug"("PASS ", "", " at pos=", rx325_pos) + .return (rx325_cur) + rx325_fail: + (rx325_rep, rx325_pos, $I10, $P10) = rx325_cur."!mark_fail"(0) + lt rx325_pos, -1, rx325_done + eq rx325_pos, -1, rx325_fail jump $I10 - rx320_done: - rx320_cur."!cursor_fail"() - rx320_cur."!cursor_debug"("FAIL ", "") - .return (rx320_cur) + rx325_done: + rx325_cur."!cursor_fail"() + rx325_cur."!cursor_debug"("FAIL ", "") + .return (rx325_cur) .return () .end .namespace ["HLL";"Grammar"] -.sub "charnames" :subid("99_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "charnames" :subid("101_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 - .local string rx323_tgt - .local int rx323_pos - .local int rx323_off - .local int rx323_eos - .local int rx323_rep - .local pmc rx323_cur - (rx323_cur, rx323_pos, rx323_tgt) = self."!cursor_start"() - rx323_cur."!cursor_debug"("START ", "charnames") - rx323_cur."!cursor_caparray"("charname") - .lex unicode:"$\x{a2}", rx323_cur + .local string rx328_tgt + .local int rx328_pos + .local int rx328_off + .local int rx328_eos + .local int rx328_rep + .local pmc rx328_cur + (rx328_cur, rx328_pos, rx328_tgt) = self."!cursor_start"() + rx328_cur."!cursor_debug"("START ", "charnames") + rx328_cur."!cursor_caparray"("charname") + .lex unicode:"$\x{a2}", rx328_cur .local pmc match .lex "$/", match - length rx323_eos, rx323_tgt - gt rx323_pos, rx323_eos, rx323_done - set rx323_off, 0 - lt rx323_pos, 2, rx323_start - sub rx323_off, rx323_pos, 1 - substr rx323_tgt, rx323_tgt, rx323_off - rx323_start: + length rx328_eos, rx328_tgt + gt rx328_pos, rx328_eos, rx328_done + set rx328_off, 0 + lt rx328_pos, 2, rx328_start + sub rx328_off, rx328_pos, 1 + substr rx328_tgt, rx328_tgt, rx328_off + rx328_start: $I10 = self.'from'() - ne $I10, -1, rxscan326_done - goto rxscan326_scan - rxscan326_loop: - ($P10) = rx323_cur."from"() + ne $I10, -1, rxscan331_done + goto rxscan331_scan + rxscan331_loop: + ($P10) = rx328_cur."from"() inc $P10 - set rx323_pos, $P10 - ge rx323_pos, rx323_eos, rxscan326_done - rxscan326_scan: - set_addr $I10, rxscan326_loop - rx323_cur."!mark_push"(0, rx323_pos, $I10) - rxscan326_done: -.annotate 'line', 115 - # rx rxquantr327 ** 1..* - set_addr $I328, rxquantr327_done - rx323_cur."!mark_push"(0, -1, $I328) - rxquantr327_loop: + set rx328_pos, $P10 + ge rx328_pos, rx328_eos, rxscan331_done + rxscan331_scan: + set_addr $I10, rxscan331_loop + rx328_cur."!mark_push"(0, rx328_pos, $I10) + rxscan331_done: +.annotate 'line', 116 + # rx rxquantr332 ** 1..* + set_addr $I333, rxquantr332_done + rx328_cur."!mark_push"(0, -1, $I333) + rxquantr332_loop: # rx subrule "ws" subtype=method negate= - rx323_cur."!cursor_pos"(rx323_pos) - $P10 = rx323_cur."ws"() - unless $P10, rx323_fail - rx323_pos = $P10."pos"() + rx328_cur."!cursor_pos"(rx328_pos) + $P10 = rx328_cur."ws"() + unless $P10, rx328_fail + rx328_pos = $P10."pos"() # rx subrule "charname" subtype=capture negate= - rx323_cur."!cursor_pos"(rx323_pos) - $P10 = rx323_cur."charname"() - unless $P10, rx323_fail - rx323_cur."!mark_push"(0, -1, 0, $P10) + rx328_cur."!cursor_pos"(rx328_pos) + $P10 = rx328_cur."charname"() + unless $P10, rx328_fail + rx328_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("charname") - rx323_pos = $P10."pos"() + rx328_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx323_cur."!cursor_pos"(rx323_pos) - $P10 = rx323_cur."ws"() - unless $P10, rx323_fail - rx323_pos = $P10."pos"() - (rx323_rep) = rx323_cur."!mark_commit"($I328) - rx323_cur."!mark_push"(rx323_rep, rx323_pos, $I328) + rx328_cur."!cursor_pos"(rx328_pos) + $P10 = rx328_cur."ws"() + unless $P10, rx328_fail + rx328_pos = $P10."pos"() + (rx328_rep) = rx328_cur."!mark_commit"($I333) + rx328_cur."!mark_push"(rx328_rep, rx328_pos, $I333) # rx literal "," - add $I11, rx323_pos, 1 - gt $I11, rx323_eos, rx323_fail - sub $I11, rx323_pos, rx323_off - substr $S10, rx323_tgt, $I11, 1 - ne $S10, ",", rx323_fail - add rx323_pos, 1 - goto rxquantr327_loop - rxquantr327_done: + add $I11, rx328_pos, 1 + gt $I11, rx328_eos, rx328_fail + sub $I11, rx328_pos, rx328_off + substr $S10, rx328_tgt, $I11, 1 + ne $S10, ",", rx328_fail + add rx328_pos, 1 + goto rxquantr332_loop + rxquantr332_done: # rx pass - rx323_cur."!cursor_pass"(rx323_pos, "charnames") - rx323_cur."!cursor_debug"("PASS ", "charnames", " at pos=", rx323_pos) - .return (rx323_cur) - rx323_fail: + rx328_cur."!cursor_pass"(rx328_pos, "charnames") + rx328_cur."!cursor_debug"("PASS ", "charnames", " at pos=", rx328_pos) + .return (rx328_cur) + rx328_fail: .annotate 'line', 33 - (rx323_rep, rx323_pos, $I10, $P10) = rx323_cur."!mark_fail"(0) - lt rx323_pos, -1, rx323_done - eq rx323_pos, -1, rx323_fail + (rx328_rep, rx328_pos, $I10, $P10) = rx328_cur."!mark_fail"(0) + lt rx328_pos, -1, rx328_done + eq rx328_pos, -1, rx328_fail jump $I10 - rx323_done: - rx323_cur."!cursor_fail"() - rx323_cur."!cursor_debug"("FAIL ", "charnames") - .return (rx323_cur) + rx328_done: + rx328_cur."!cursor_fail"() + rx328_cur."!cursor_debug"("FAIL ", "charnames") + .return (rx328_cur) .return () .end .namespace ["HLL";"Grammar"] -.sub "!PREFIX__charnames" :subid("100_1275511685.92888") :method +.sub "!PREFIX__charnames" :subid("102_1275599990.60173") :method .annotate 'line', 33 - new $P325, "ResizablePMCArray" - push $P325, "" - .return ($P325) + new $P330, "ResizablePMCArray" + push $P330, "" + .return ($P330) .end .namespace ["HLL";"Grammar"] -.sub "charspec" :subid("101_1275511685.92888") :method :outer("11_1275511685.92888") +.sub "charspec" :subid("103_1275599990.60173") :method :outer("11_1275599990.60173") .annotate 'line', 33 - .local string rx330_tgt - .local int rx330_pos - .local int rx330_off - .local int rx330_eos - .local int rx330_rep - .local pmc rx330_cur - (rx330_cur, rx330_pos, rx330_tgt) = self."!cursor_start"() - rx330_cur."!cursor_debug"("START ", "charspec") - .lex unicode:"$\x{a2}", rx330_cur + .local string rx335_tgt + .local int rx335_pos + .local int rx335_off + .local int rx335_eos + .local int rx335_rep + .local pmc rx335_cur + (rx335_cur, rx335_pos, rx335_tgt) = self."!cursor_start"() + rx335_cur."!cursor_debug"("START ", "charspec") + .lex unicode:"$\x{a2}", rx335_cur .local pmc match .lex "$/", match - length rx330_eos, rx330_tgt - gt rx330_pos, rx330_eos, rx330_done - set rx330_off, 0 - lt rx330_pos, 2, rx330_start - sub rx330_off, rx330_pos, 1 - substr rx330_tgt, rx330_tgt, rx330_off - rx330_start: + length rx335_eos, rx335_tgt + gt rx335_pos, rx335_eos, rx335_done + set rx335_off, 0 + lt rx335_pos, 2, rx335_start + sub rx335_off, rx335_pos, 1 + substr rx335_tgt, rx335_tgt, rx335_off + rx335_start: $I10 = self.'from'() - ne $I10, -1, rxscan335_done - goto rxscan335_scan - rxscan335_loop: - ($P10) = rx330_cur."from"() + ne $I10, -1, rxscan340_done + goto rxscan340_scan + rxscan340_loop: + ($P10) = rx335_cur."from"() inc $P10 - set rx330_pos, $P10 - ge rx330_pos, rx330_eos, rxscan335_done - rxscan335_scan: - set_addr $I10, rxscan335_loop - rx330_cur."!mark_push"(0, rx330_pos, $I10) - rxscan335_done: - alt336_0: -.annotate 'line', 117 - set_addr $I10, alt336_1 - rx330_cur."!mark_push"(0, rx330_pos, $I10) + set rx335_pos, $P10 + ge rx335_pos, rx335_eos, rxscan340_done + rxscan340_scan: + set_addr $I10, rxscan340_loop + rx335_cur."!mark_push"(0, rx335_pos, $I10) + rxscan340_done: + alt341_0: .annotate 'line', 118 + set_addr $I10, alt341_1 + rx335_cur."!mark_push"(0, rx335_pos, $I10) +.annotate 'line', 119 # rx literal "[" - add $I11, rx330_pos, 1 - gt $I11, rx330_eos, rx330_fail - sub $I11, rx330_pos, rx330_off - substr $S10, rx330_tgt, $I11, 1 - ne $S10, "[", rx330_fail - add rx330_pos, 1 + add $I11, rx335_pos, 1 + gt $I11, rx335_eos, rx335_fail + sub $I11, rx335_pos, rx335_off + substr $S10, rx335_tgt, $I11, 1 + ne $S10, "[", rx335_fail + add rx335_pos, 1 # rx subrule "charnames" subtype=capture negate= - rx330_cur."!cursor_pos"(rx330_pos) - $P10 = rx330_cur."charnames"() - unless $P10, rx330_fail - rx330_cur."!mark_push"(0, -1, 0, $P10) + rx335_cur."!cursor_pos"(rx335_pos) + $P10 = rx335_cur."charnames"() + unless $P10, rx335_fail + rx335_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("charnames") - rx330_pos = $P10."pos"() + rx335_pos = $P10."pos"() # rx literal "]" - add $I11, rx330_pos, 1 - gt $I11, rx330_eos, rx330_fail - sub $I11, rx330_pos, rx330_off - substr $S10, rx330_tgt, $I11, 1 - ne $S10, "]", rx330_fail - add rx330_pos, 1 - goto alt336_end - alt336_1: - set_addr $I10, alt336_2 - rx330_cur."!mark_push"(0, rx330_pos, $I10) -.annotate 'line', 119 + add $I11, rx335_pos, 1 + gt $I11, rx335_eos, rx335_fail + sub $I11, rx335_pos, rx335_off + substr $S10, rx335_tgt, $I11, 1 + ne $S10, "]", rx335_fail + add rx335_pos, 1 + goto alt341_end + alt341_1: + set_addr $I10, alt341_2 + rx335_cur."!mark_push"(0, rx335_pos, $I10) +.annotate 'line', 120 # rx charclass_q d r 1..-1 - sub $I10, rx330_pos, rx330_off - find_not_cclass $I11, 8, rx330_tgt, $I10, rx330_eos + sub $I10, rx335_pos, rx335_off + find_not_cclass $I11, 8, rx335_tgt, $I10, rx335_eos add $I12, $I10, 1 - lt $I11, $I12, rx330_fail - add rx330_pos, rx330_off, $I11 - # rx rxquantr337 ** 0..* - set_addr $I338, rxquantr337_done - rx330_cur."!mark_push"(0, rx330_pos, $I338) - rxquantr337_loop: + lt $I11, $I12, rx335_fail + add rx335_pos, rx335_off, $I11 + # rx rxquantr342 ** 0..* + set_addr $I343, rxquantr342_done + rx335_cur."!mark_push"(0, rx335_pos, $I343) + rxquantr342_loop: # rx literal "_" - add $I11, rx330_pos, 1 - gt $I11, rx330_eos, rx330_fail - sub $I11, rx330_pos, rx330_off - substr $S10, rx330_tgt, $I11, 1 - ne $S10, "_", rx330_fail - add rx330_pos, 1 + add $I11, rx335_pos, 1 + gt $I11, rx335_eos, rx335_fail + sub $I11, rx335_pos, rx335_off + substr $S10, rx335_tgt, $I11, 1 + ne $S10, "_", rx335_fail + add rx335_pos, 1 # rx charclass_q d r 1..-1 - sub $I10, rx330_pos, rx330_off - find_not_cclass $I11, 8, rx330_tgt, $I10, rx330_eos + sub $I10, rx335_pos, rx335_off + find_not_cclass $I11, 8, rx335_tgt, $I10, rx335_eos add $I12, $I10, 1 - lt $I11, $I12, rx330_fail - add rx330_pos, rx330_off, $I11 - (rx330_rep) = rx330_cur."!mark_commit"($I338) - rx330_cur."!mark_push"(rx330_rep, rx330_pos, $I338) - goto rxquantr337_loop - rxquantr337_done: - goto alt336_end - alt336_2: - set_addr $I10, alt336_3 - rx330_cur."!mark_push"(0, rx330_pos, $I10) -.annotate 'line', 120 + lt $I11, $I12, rx335_fail + add rx335_pos, rx335_off, $I11 + (rx335_rep) = rx335_cur."!mark_commit"($I343) + rx335_cur."!mark_push"(rx335_rep, rx335_pos, $I343) + goto rxquantr342_loop + rxquantr342_done: + goto alt341_end + alt341_2: + set_addr $I10, alt341_3 + rx335_cur."!mark_push"(0, rx335_pos, $I10) +.annotate 'line', 121 # rx enumcharlist negate=0 - ge rx330_pos, rx330_eos, rx330_fail - sub $I10, rx330_pos, rx330_off - substr $S10, rx330_tgt, $I10, 1 + ge rx335_pos, rx335_eos, rx335_fail + sub $I10, rx335_pos, rx335_off + substr $S10, rx335_tgt, $I10, 1 index $I11, "?@ABCDEFGHIJKLMNOPQRSTUVWXYZ", $S10 - lt $I11, 0, rx330_fail - inc rx330_pos - goto alt336_end - alt336_3: -.annotate 'line', 121 + lt $I11, 0, rx335_fail + inc rx335_pos + goto alt341_end + alt341_3: +.annotate 'line', 122 # rx subrule "panic" subtype=method negate= - rx330_cur."!cursor_pos"(rx330_pos) - $P10 = rx330_cur."panic"("Unrecognized \\c character") - unless $P10, rx330_fail - rx330_pos = $P10."pos"() - alt336_end: -.annotate 'line', 116 + rx335_cur."!cursor_pos"(rx335_pos) + $P10 = rx335_cur."panic"("Unrecognized \\c character") + unless $P10, rx335_fail + rx335_pos = $P10."pos"() + alt341_end: +.annotate 'line', 117 # rx pass - rx330_cur."!cursor_pass"(rx330_pos, "charspec") - rx330_cur."!cursor_debug"("PASS ", "charspec", " at pos=", rx330_pos) - .return (rx330_cur) - rx330_fail: + rx335_cur."!cursor_pass"(rx335_pos, "charspec") + rx335_cur."!cursor_debug"("PASS ", "charspec", " at pos=", rx335_pos) + .return (rx335_cur) + rx335_fail: .annotate 'line', 33 - (rx330_rep, rx330_pos, $I10, $P10) = rx330_cur."!mark_fail"(0) - lt rx330_pos, -1, rx330_done - eq rx330_pos, -1, rx330_fail + (rx335_rep, rx335_pos, $I10, $P10) = rx335_cur."!mark_fail"(0) + lt rx335_pos, -1, rx335_done + eq rx335_pos, -1, rx335_fail jump $I10 - rx330_done: - rx330_cur."!cursor_fail"() - rx330_cur."!cursor_debug"("FAIL ", "charspec") - .return (rx330_cur) + rx335_done: + rx335_cur."!cursor_fail"() + rx335_cur."!cursor_debug"("FAIL ", "charspec") + .return (rx335_cur) .return () .end .namespace ["HLL";"Grammar"] -.sub "!PREFIX__charspec" :subid("102_1275511685.92888") :method +.sub "!PREFIX__charspec" :subid("104_1275599990.60173") :method .annotate 'line', 33 - $P332 = self."!PREFIX__!subrule"("", "") - $P333 = self."!PREFIX__!subrule"("charnames", "[") - new $P334, "ResizablePMCArray" - push $P334, $P332 - push $P334, "Z" - push $P334, "Y" - push $P334, "X" - push $P334, "W" - push $P334, "V" - push $P334, "U" - push $P334, "T" - push $P334, "S" - push $P334, "R" - push $P334, "Q" - push $P334, "P" - push $P334, "O" - push $P334, "N" - push $P334, "M" - push $P334, "L" - push $P334, "K" - push $P334, "J" - push $P334, "I" - push $P334, "H" - push $P334, "G" - push $P334, "F" - push $P334, "E" - push $P334, "D" - push $P334, "C" - push $P334, "B" - push $P334, "A" - push $P334, "@" - push $P334, "?" - push $P334, "" - push $P334, $P333 - .return ($P334) + $P337 = self."!PREFIX__!subrule"("", "") + $P338 = self."!PREFIX__!subrule"("charnames", "[") + new $P339, "ResizablePMCArray" + push $P339, $P337 + push $P339, "Z" + push $P339, "Y" + push $P339, "X" + push $P339, "W" + push $P339, "V" + push $P339, "U" + push $P339, "T" + push $P339, "S" + push $P339, "R" + push $P339, "Q" + push $P339, "P" + push $P339, "O" + push $P339, "N" + push $P339, "M" + push $P339, "L" + push $P339, "K" + push $P339, "J" + push $P339, "I" + push $P339, "H" + push $P339, "G" + push $P339, "F" + push $P339, "E" + push $P339, "D" + push $P339, "C" + push $P339, "B" + push $P339, "A" + push $P339, "@" + push $P339, "?" + push $P339, "" + push $P339, $P338 + .return ($P339) .end .namespace ["HLL";"Grammar"] -.sub "_block339" :load :anon :subid("103_1275511685.92888") +.sub "_block344" :load :anon :subid("105_1275599990.60173") .annotate 'line', 5 - .const 'Sub' $P341 = "11_1275511685.92888" - $P342 = $P341() - .return ($P342) + .const 'Sub' $P346 = "11_1275599990.60173" + $P347 = $P346() + .return ($P347) .end .namespace [] -.sub "_block344" :load :anon :subid("104_1275511685.92888") +.sub "_block349" :load :anon :subid("106_1275599990.60173") .annotate 'line', 1 - .const 'Sub' $P346 = "10_1275511685.92888" - $P347 = $P346() - .return ($P347) + .const 'Sub' $P351 = "10_1275599990.60173" + $P352 = $P351() + .return ($P352) .end ### .include 'gen/hllgrammar-actions.pir' .namespace [] -.sub "_block11" :anon :subid("10_1275511694.5657") +.sub "_block11" :anon :subid("10_1275599992.78953") .annotate 'line', 0 get_hll_global $P14, ["HLL";"Actions"], "_block13" capture_lex $P14 @@ -4835,93 +4909,95 @@ An operator precedence parser. .annotate 'line', 3 get_hll_global $P14, ["HLL";"Actions"], "_block13" capture_lex $P14 - $P620 = $P14() + $P627 = $P14() .annotate 'line', 1 - .return ($P620) - .const 'Sub' $P622 = "54_1275511694.5657" - .return ($P622) + .return ($P627) + .const 'Sub' $P629 = "55_1275599992.78953" + .return ($P629) .end .namespace [] -.sub "" :load :init :subid("post55") :outer("10_1275511694.5657") +.sub "" :load :init :subid("post56") :outer("10_1275599992.78953") .annotate 'line', 0 - .const 'Sub' $P12 = "10_1275511694.5657" + .const 'Sub' $P12 = "10_1275599992.78953" .local pmc block set block, $P12 - $P625 = get_root_global ["parrot"], "P6metaclass" - $P625."new_class"("HLL::Actions") + $P632 = get_root_global ["parrot"], "P6metaclass" + $P632."new_class"("HLL::Actions") .end .namespace ["HLL";"Actions"] -.sub "_block13" :subid("11_1275511694.5657") :outer("10_1275511694.5657") +.sub "_block13" :subid("11_1275599992.78953") :outer("10_1275599992.78953") .annotate 'line', 3 - .const 'Sub' $P598 = "52_1275511694.5657" - capture_lex $P598 - .const 'Sub' $P573 = "50_1275511694.5657" - capture_lex $P573 - .const 'Sub' $P543 = "49_1275511694.5657" - capture_lex $P543 - .const 'Sub' $P524 = "48_1275511694.5657" + .const 'Sub' $P605 = "53_1275599992.78953" + capture_lex $P605 + .const 'Sub' $P580 = "51_1275599992.78953" + capture_lex $P580 + .const 'Sub' $P550 = "50_1275599992.78953" + capture_lex $P550 + .const 'Sub' $P531 = "49_1275599992.78953" + capture_lex $P531 + .const 'Sub' $P524 = "48_1275599992.78953" capture_lex $P524 - .const 'Sub' $P517 = "47_1275511694.5657" - capture_lex $P517 - .const 'Sub' $P507 = "46_1275511694.5657" - capture_lex $P507 - .const 'Sub' $P490 = "45_1275511694.5657" - capture_lex $P490 - .const 'Sub' $P473 = "44_1275511694.5657" + .const 'Sub' $P514 = "47_1275599992.78953" + capture_lex $P514 + .const 'Sub' $P497 = "46_1275599992.78953" + capture_lex $P497 + .const 'Sub' $P480 = "45_1275599992.78953" + capture_lex $P480 + .const 'Sub' $P473 = "44_1275599992.78953" capture_lex $P473 - .const 'Sub' $P466 = "43_1275511694.5657" + .const 'Sub' $P466 = "43_1275599992.78953" capture_lex $P466 - .const 'Sub' $P459 = "42_1275511694.5657" + .const 'Sub' $P459 = "42_1275599992.78953" capture_lex $P459 - .const 'Sub' $P452 = "41_1275511694.5657" + .const 'Sub' $P452 = "41_1275599992.78953" capture_lex $P452 - .const 'Sub' $P445 = "40_1275511694.5657" + .const 'Sub' $P445 = "40_1275599992.78953" capture_lex $P445 - .const 'Sub' $P438 = "39_1275511694.5657" + .const 'Sub' $P438 = "39_1275599992.78953" capture_lex $P438 - .const 'Sub' $P428 = "38_1275511694.5657" + .const 'Sub' $P428 = "38_1275599992.78953" capture_lex $P428 - .const 'Sub' $P421 = "37_1275511694.5657" + .const 'Sub' $P421 = "37_1275599992.78953" capture_lex $P421 - .const 'Sub' $P405 = "36_1275511694.5657" + .const 'Sub' $P405 = "36_1275599992.78953" capture_lex $P405 - .const 'Sub' $P330 = "34_1275511694.5657" + .const 'Sub' $P330 = "34_1275599992.78953" capture_lex $P330 - .const 'Sub' $P267 = "31_1275511694.5657" + .const 'Sub' $P267 = "31_1275599992.78953" capture_lex $P267 - .const 'Sub' $P258 = "30_1275511694.5657" + .const 'Sub' $P258 = "30_1275599992.78953" capture_lex $P258 - .const 'Sub' $P249 = "29_1275511694.5657" + .const 'Sub' $P249 = "29_1275599992.78953" capture_lex $P249 - .const 'Sub' $P240 = "28_1275511694.5657" + .const 'Sub' $P240 = "28_1275599992.78953" capture_lex $P240 - .const 'Sub' $P231 = "27_1275511694.5657" + .const 'Sub' $P231 = "27_1275599992.78953" capture_lex $P231 - .const 'Sub' $P222 = "26_1275511694.5657" + .const 'Sub' $P222 = "26_1275599992.78953" capture_lex $P222 - .const 'Sub' $P212 = "25_1275511694.5657" + .const 'Sub' $P212 = "25_1275599992.78953" capture_lex $P212 - .const 'Sub' $P202 = "24_1275511694.5657" + .const 'Sub' $P202 = "24_1275599992.78953" capture_lex $P202 - .const 'Sub' $P194 = "23_1275511694.5657" + .const 'Sub' $P194 = "23_1275599992.78953" capture_lex $P194 - .const 'Sub' $P184 = "22_1275511694.5657" + .const 'Sub' $P184 = "22_1275599992.78953" capture_lex $P184 - .const 'Sub' $P174 = "21_1275511694.5657" + .const 'Sub' $P174 = "21_1275599992.78953" capture_lex $P174 - .const 'Sub' $P73 = "18_1275511694.5657" + .const 'Sub' $P73 = "18_1275599992.78953" capture_lex $P73 - .const 'Sub' $P35 = "15_1275511694.5657" + .const 'Sub' $P35 = "15_1275599992.78953" capture_lex $P35 - .const 'Sub' $P28 = "14_1275511694.5657" + .const 'Sub' $P28 = "14_1275599992.78953" capture_lex $P28 - .const 'Sub' $P22 = "13_1275511694.5657" + .const 'Sub' $P22 = "13_1275599992.78953" capture_lex $P22 - .const 'Sub' $P15 = "12_1275511694.5657" + .const 'Sub' $P15 = "12_1275599992.78953" capture_lex $P15 $P0 = find_dynamic_lex "$*CTXSAVE" if null $P0 goto ctxsave_done @@ -4929,18 +5005,18 @@ An operator precedence parser. unless $I0 goto ctxsave_done $P0."ctxsave"() ctxsave_done: -.annotate 'line', 224 - .const 'Sub' $P598 = "52_1275511694.5657" - newclosure $P615, $P598 +.annotate 'line', 225 + .const 'Sub' $P605 = "53_1275599992.78953" + newclosure $P622, $P605 .annotate 'line', 3 - .return ($P615) - .const 'Sub' $P617 = "53_1275511694.5657" - .return ($P617) + .return ($P622) + .const 'Sub' $P624 = "54_1275599992.78953" + .return ($P624) .end .namespace ["HLL";"Actions"] -.sub "string_to_int" :subid("12_1275511694.5657") :outer("11_1275511694.5657") +.sub "string_to_int" :subid("12_1275599992.78953") :outer("11_1275599992.78953") .param pmc param_18 .param pmc param_19 .annotate 'line', 3 @@ -4993,7 +5069,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "ints_to_string" :subid("13_1275511694.5657") :outer("11_1275511694.5657") +.sub "ints_to_string" :subid("13_1275599992.78953") :outer("11_1275599992.78953") .param pmc param_25 .annotate 'line', 37 new $P24, 'ExceptionHandler' @@ -5034,7 +5110,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "CTXSAVE" :subid("14_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "CTXSAVE" :subid("14_1275599992.78953") :method :outer("11_1275599992.78953") .annotate 'line', 62 new $P30, 'ExceptionHandler' set_addr $P30, control_29 @@ -5063,10 +5139,10 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "SET_BLOCK_OUTER_CTX" :subid("15_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "SET_BLOCK_OUTER_CTX" :subid("15_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_38 .annotate 'line', 76 - .const 'Sub' $P48 = "16_1275511694.5657" + .const 'Sub' $P48 = "16_1275599992.78953" capture_lex $P48 new $P37, 'ExceptionHandler' set_addr $P37, control_36 @@ -5078,20 +5154,20 @@ An operator precedence parser. new $P39, "Undef" .lex "$outer_ctx", $P39 find_dynamic_lex $P40, "%*COMPILING" - unless_null $P40, vivify_56 - get_hll_global $P40, "%COMPILING" unless_null $P40, vivify_57 + get_hll_global $P40, "%COMPILING" + unless_null $P40, vivify_58 die "Contextual %*COMPILING not found" + vivify_58: vivify_57: - vivify_56: set $P41, $P40["%?OPTIONS"] - unless_null $P41, vivify_58 + unless_null $P41, vivify_59 $P41 = root_new ['parrot';'Hash'] - vivify_58: + vivify_59: set $P42, $P41["outer_ctx"] - unless_null $P42, vivify_59 + unless_null $P42, vivify_60 new $P42, "Undef" - vivify_59: + vivify_60: store_lex "$outer_ctx", $P42 .annotate 'line', 78 find_lex $P45, "$outer_ctx" @@ -5101,7 +5177,7 @@ An operator precedence parser. set $P43, $I46 goto if_44_end if_44: - .const 'Sub' $P48 = "16_1275511694.5657" + .const 'Sub' $P48 = "16_1275599992.78953" capture_lex $P48 $P71 = $P48() set $P43, $P71 @@ -5117,9 +5193,9 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "_block47" :anon :subid("16_1275511694.5657") :outer("15_1275511694.5657") +.sub "_block47" :anon :subid("16_1275599992.78953") :outer("15_1275599992.78953") .annotate 'line', 78 - .const 'Sub' $P62 = "17_1275511694.5657" + .const 'Sub' $P62 = "17_1275599992.78953" capture_lex $P62 .annotate 'line', 79 $P49 = root_new ['parrot';'ResizablePMCArray'] @@ -5139,7 +5215,7 @@ An operator precedence parser. find_lex $P57, "$outer_ctx" $P58 = $P57."lexpad_full"() defined $I59, $P58 - unless $I59, for_undef_60 + unless $I59, for_undef_61 iter $P56, $P58 new $P69, 'ExceptionHandler' set_addr $P69, loop68_handler @@ -5149,7 +5225,7 @@ An operator precedence parser. unless $P56, loop68_done shift $P60, $P56 loop68_redo: - .const 'Sub' $P62 = "17_1275511694.5657" + .const 'Sub' $P62 = "17_1275599992.78953" capture_lex $P62 $P62($P60) loop68_next: @@ -5162,14 +5238,14 @@ An operator precedence parser. eq $P70, 66, loop68_redo loop68_done: pop_eh - for_undef_60: + for_undef_61: .annotate 'line', 78 .return ($P56) .end .namespace ["HLL";"Actions"] -.sub "_block61" :anon :subid("17_1275511694.5657") :outer("16_1275511694.5657") +.sub "_block61" :anon :subid("17_1275599992.78953") :outer("16_1275599992.78953") .param pmc param_63 .annotate 'line', 82 .lex "$_", param_63 @@ -5184,14 +5260,14 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "EXPR" :subid("18_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "EXPR" :subid("18_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_76 .param pmc param_77 :optional .param int has_param_77 :opt_flag .annotate 'line', 89 - .const 'Sub' $P156 = "20_1275511694.5657" + .const 'Sub' $P156 = "20_1275599992.78953" capture_lex $P156 - .const 'Sub' $P123 = "19_1275511694.5657" + .const 'Sub' $P123 = "19_1275599992.78953" capture_lex $P123 new $P75, 'ExceptionHandler' set_addr $P75, control_74 @@ -5199,10 +5275,10 @@ An operator precedence parser. push_eh $P75 .lex "self", self .lex "$/", param_76 - if has_param_77, optparam_61 + if has_param_77, optparam_62 new $P78, "Undef" set param_77, $P78 - optparam_61: + optparam_62: .lex "$key", param_77 .annotate 'line', 91 new $P79, "Undef" @@ -5224,13 +5300,13 @@ An operator precedence parser. defined $I88, $P84 if $I88, default_87 find_lex $P89, "$/" - unless_null $P89, vivify_62 + unless_null $P89, vivify_63 $P89 = root_new ['parrot';'Hash'] - vivify_62: + vivify_63: set $P90, $P89["OPER"] - unless_null $P90, vivify_63 + unless_null $P90, vivify_64 new $P90, "Undef" - vivify_63: + vivify_64: $P91 = $P90."ast"() set $P84, $P91 default_87: @@ -5245,57 +5321,57 @@ An operator precedence parser. store_lex "$past", $P96 .annotate 'line', 94 find_lex $P98, "$/" - unless_null $P98, vivify_64 + unless_null $P98, vivify_65 $P98 = root_new ['parrot';'Hash'] - vivify_64: + vivify_65: set $P99, $P98["OPER"] - unless_null $P99, vivify_65 + unless_null $P99, vivify_66 $P99 = root_new ['parrot';'Hash'] - vivify_65: + vivify_66: set $P100, $P99["O"] - unless_null $P100, vivify_66 + unless_null $P100, vivify_67 $P100 = root_new ['parrot';'Hash'] - vivify_66: + vivify_67: set $P101, $P100["pasttype"] - unless_null $P101, vivify_67 + unless_null $P101, vivify_68 new $P101, "Undef" - vivify_67: + vivify_68: if $P101, if_97 .annotate 'line', 95 find_lex $P109, "$/" - unless_null $P109, vivify_68 + unless_null $P109, vivify_69 $P109 = root_new ['parrot';'Hash'] - vivify_68: + vivify_69: set $P110, $P109["OPER"] - unless_null $P110, vivify_69 + unless_null $P110, vivify_70 $P110 = root_new ['parrot';'Hash'] - vivify_69: + vivify_70: set $P111, $P110["O"] - unless_null $P111, vivify_70 + unless_null $P111, vivify_71 $P111 = root_new ['parrot';'Hash'] - vivify_70: + vivify_71: set $P112, $P111["pirop"] - unless_null $P112, vivify_71 + unless_null $P112, vivify_72 new $P112, "Undef" - vivify_71: + vivify_72: unless $P112, if_108_end find_lex $P113, "$past" find_lex $P114, "$/" - unless_null $P114, vivify_72 + unless_null $P114, vivify_73 $P114 = root_new ['parrot';'Hash'] - vivify_72: + vivify_73: set $P115, $P114["OPER"] - unless_null $P115, vivify_73 + unless_null $P115, vivify_74 $P115 = root_new ['parrot';'Hash'] - vivify_73: + vivify_74: set $P116, $P115["O"] - unless_null $P116, vivify_74 + unless_null $P116, vivify_75 $P116 = root_new ['parrot';'Hash'] - vivify_74: + vivify_75: set $P117, $P116["pirop"] - unless_null $P117, vivify_75 + unless_null $P117, vivify_76 new $P117, "Undef" - vivify_75: + vivify_76: set $S118, $P117 $P113."pirop"($S118) if_108_end: @@ -5304,21 +5380,21 @@ An operator precedence parser. .annotate 'line', 94 find_lex $P102, "$past" find_lex $P103, "$/" - unless_null $P103, vivify_76 + unless_null $P103, vivify_77 $P103 = root_new ['parrot';'Hash'] - vivify_76: + vivify_77: set $P104, $P103["OPER"] - unless_null $P104, vivify_77 + unless_null $P104, vivify_78 $P104 = root_new ['parrot';'Hash'] - vivify_77: + vivify_78: set $P105, $P104["O"] - unless_null $P105, vivify_78 + unless_null $P105, vivify_79 $P105 = root_new ['parrot';'Hash'] - vivify_78: + vivify_79: set $P106, $P105["pasttype"] - unless_null $P106, vivify_79 + unless_null $P106, vivify_80 new $P106, "Undef" - vivify_79: + vivify_80: set $S107, $P106 $P102."pasttype"($S107) if_97_end: @@ -5326,7 +5402,7 @@ An operator precedence parser. find_lex $P120, "$past" $P121 = $P120."name"() if $P121, unless_119_end - .const 'Sub' $P123 = "19_1275511694.5657" + .const 'Sub' $P123 = "19_1275599992.78953" capture_lex $P123 $P123() unless_119_end: @@ -5340,7 +5416,7 @@ An operator precedence parser. find_lex $P151, "$/" $P152 = $P151."list"() defined $I153, $P152 - unless $I153, for_undef_83 + unless $I153, for_undef_84 iter $P150, $P152 new $P168, 'ExceptionHandler' set_addr $P168, loop167_handler @@ -5350,7 +5426,7 @@ An operator precedence parser. unless $P150, loop167_done shift $P154, $P150 loop167_redo: - .const 'Sub' $P156 = "20_1275511694.5657" + .const 'Sub' $P156 = "20_1275599992.78953" capture_lex $P156 $P156($P154) loop167_next: @@ -5363,20 +5439,20 @@ An operator precedence parser. eq $P169, 66, loop167_redo loop167_done: pop_eh - for_undef_83: + for_undef_84: .annotate 'line', 108 goto if_142_end if_142: .annotate 'line', 107 find_lex $P146, "$past" find_lex $P147, "$/" - unless_null $P147, vivify_84 + unless_null $P147, vivify_85 $P147 = root_new ['parrot';'ResizablePMCArray'] - vivify_84: + vivify_85: set $P148, $P147[0] - unless_null $P148, vivify_85 + unless_null $P148, vivify_86 new $P148, "Undef" - vivify_85: + vivify_86: $P149 = $P148."ast"() $P146."unshift"($P149) if_142_end: @@ -5395,7 +5471,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "_block122" :anon :subid("19_1275511694.5657") :outer("18_1275511694.5657") +.sub "_block122" :anon :subid("19_1275599992.78953") :outer("18_1275599992.78953") .annotate 'line', 98 new $P124, "Undef" .lex "$name", $P124 @@ -5418,17 +5494,17 @@ An operator precedence parser. concat $P131, $P130, ":<" .annotate 'line', 103 find_lex $P132, "$/" - unless_null $P132, vivify_80 + unless_null $P132, vivify_81 $P132 = root_new ['parrot';'Hash'] - vivify_80: + vivify_81: set $P133, $P132["OPER"] - unless_null $P133, vivify_81 + unless_null $P133, vivify_82 $P133 = root_new ['parrot';'Hash'] - vivify_81: + vivify_82: set $P134, $P133["sym"] - unless_null $P134, vivify_82 + unless_null $P134, vivify_83 new $P134, "Undef" - vivify_82: + vivify_83: concat $P135, $P131, $P134 concat $P136, $P135, ">" store_lex "$name", $P136 @@ -5445,7 +5521,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "_block155" :anon :subid("20_1275511694.5657") :outer("18_1275511694.5657") +.sub "_block155" :anon :subid("20_1275599992.78953") :outer("18_1275599992.78953") .param pmc param_157 .annotate 'line', 109 .lex "$_", param_157 @@ -5468,7 +5544,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "term:sym" :subid("21_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "term:sym" :subid("21_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_177 .annotate 'line', 114 new $P176, 'ExceptionHandler' @@ -5479,13 +5555,13 @@ An operator precedence parser. .lex "$/", param_177 find_lex $P178, "$/" find_lex $P179, "$/" - unless_null $P179, vivify_86 + unless_null $P179, vivify_87 $P179 = root_new ['parrot';'Hash'] - vivify_86: + vivify_87: set $P180, $P179["circumfix"] - unless_null $P180, vivify_87 + unless_null $P180, vivify_88 new $P180, "Undef" - vivify_87: + vivify_88: $P181 = $P180."ast"() $P182 = $P178."!make"($P181) .return ($P182) @@ -5498,7 +5574,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "termish" :subid("22_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "termish" :subid("22_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_187 .annotate 'line', 116 new $P186, 'ExceptionHandler' @@ -5509,13 +5585,13 @@ An operator precedence parser. .lex "$/", param_187 find_lex $P188, "$/" find_lex $P189, "$/" - unless_null $P189, vivify_88 + unless_null $P189, vivify_89 $P189 = root_new ['parrot';'Hash'] - vivify_88: + vivify_89: set $P190, $P189["term"] - unless_null $P190, vivify_89 + unless_null $P190, vivify_90 new $P190, "Undef" - vivify_89: + vivify_90: $P191 = $P190."ast"() $P192 = $P188."!make"($P191) .return ($P192) @@ -5528,7 +5604,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "nullterm" :subid("23_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "nullterm" :subid("23_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_197 .annotate 'line', 117 new $P196, 'ExceptionHandler' @@ -5550,7 +5626,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "nullterm_alt" :subid("24_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "nullterm_alt" :subid("24_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_205 .annotate 'line', 118 new $P204, 'ExceptionHandler' @@ -5561,13 +5637,13 @@ An operator precedence parser. .lex "$/", param_205 find_lex $P206, "$/" find_lex $P207, "$/" - unless_null $P207, vivify_90 + unless_null $P207, vivify_91 $P207 = root_new ['parrot';'Hash'] - vivify_90: + vivify_91: set $P208, $P207["term"] - unless_null $P208, vivify_91 + unless_null $P208, vivify_92 new $P208, "Undef" - vivify_91: + vivify_92: $P209 = $P208."ast"() $P210 = $P206."!make"($P209) .return ($P210) @@ -5580,7 +5656,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "integer" :subid("25_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "integer" :subid("25_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_215 .annotate 'line', 120 new $P214, 'ExceptionHandler' @@ -5591,13 +5667,13 @@ An operator precedence parser. .lex "$/", param_215 find_lex $P216, "$/" find_lex $P217, "$/" - unless_null $P217, vivify_92 + unless_null $P217, vivify_93 $P217 = root_new ['parrot';'Hash'] - vivify_92: + vivify_93: set $P218, $P217["VALUE"] - unless_null $P218, vivify_93 + unless_null $P218, vivify_94 new $P218, "Undef" - vivify_93: + vivify_94: $P219 = $P218."ast"() $P220 = $P216."!make"($P219) .return ($P220) @@ -5610,7 +5686,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "dec_number" :subid("26_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "dec_number" :subid("26_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_225 .annotate 'line', 122 new $P224, 'ExceptionHandler' @@ -5633,7 +5709,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "decint" :subid("27_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "decint" :subid("27_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_234 .annotate 'line', 124 new $P233, 'ExceptionHandler' @@ -5656,7 +5732,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "hexint" :subid("28_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "hexint" :subid("28_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_243 .annotate 'line', 125 new $P242, 'ExceptionHandler' @@ -5679,7 +5755,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "octint" :subid("29_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "octint" :subid("29_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_252 .annotate 'line', 126 new $P251, 'ExceptionHandler' @@ -5702,7 +5778,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "binint" :subid("30_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "binint" :subid("30_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_261 .annotate 'line', 127 new $P260, 'ExceptionHandler' @@ -5725,10 +5801,10 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "quote_EXPR" :subid("31_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "quote_EXPR" :subid("31_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_270 .annotate 'line', 129 - .const 'Sub' $P286 = "32_1275511694.5657" + .const 'Sub' $P286 = "32_1275599992.78953" capture_lex $P286 new $P269, 'ExceptionHandler' set_addr $P269, control_268 @@ -5740,13 +5816,13 @@ An operator precedence parser. new $P271, "Undef" .lex "$past", $P271 find_lex $P272, "$/" - unless_null $P272, vivify_94 + unless_null $P272, vivify_95 $P272 = root_new ['parrot';'Hash'] - vivify_94: + vivify_95: set $P273, $P272["quote_delimited"] - unless_null $P273, vivify_95 + unless_null $P273, vivify_96 new $P273, "Undef" - vivify_95: + vivify_96: $P274 = $P273."ast"() store_lex "$past", $P274 .annotate 'line', 131 @@ -5760,7 +5836,7 @@ An operator precedence parser. $P282 = $P280."ACCEPTS"($P281) if $P282, if_279 .annotate 'line', 135 - .const 'Sub' $P286 = "32_1275511694.5657" + .const 'Sub' $P286 = "32_1275599992.78953" capture_lex $P286 $P286() goto if_279_end @@ -5799,9 +5875,9 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "_block285" :anon :subid("32_1275511694.5657") :outer("31_1275511694.5657") +.sub "_block285" :anon :subid("32_1275599992.78953") :outer("31_1275599992.78953") .annotate 'line', 135 - .const 'Sub' $P305 = "33_1275511694.5657" + .const 'Sub' $P305 = "33_1275599992.78953" capture_lex $P305 .annotate 'line', 136 $P287 = root_new ['parrot';'ResizablePMCArray'] @@ -5818,13 +5894,13 @@ An operator precedence parser. if $I296, if_293 .annotate 'line', 142 find_lex $P313, "@words" - unless_null $P313, vivify_96 + unless_null $P313, vivify_97 $P313 = root_new ['parrot';'ResizablePMCArray'] - vivify_96: + vivify_97: set $P314, $P313[0] - unless_null $P314, vivify_97 + unless_null $P314, vivify_98 new $P314, "Undef" - vivify_97: + vivify_98: set $S315, $P314 new $P316, 'String' set $P316, $S315 @@ -5842,7 +5918,7 @@ An operator precedence parser. .annotate 'line', 139 find_lex $P301, "@words" defined $I302, $P301 - unless $I302, for_undef_98 + unless $I302, for_undef_99 iter $P300, $P301 new $P311, 'ExceptionHandler' set_addr $P311, loop310_handler @@ -5852,7 +5928,7 @@ An operator precedence parser. unless $P300, loop310_done shift $P303, $P300 loop310_redo: - .const 'Sub' $P305 = "33_1275511694.5657" + .const 'Sub' $P305 = "33_1275599992.78953" capture_lex $P305 $P305($P303) loop310_next: @@ -5865,7 +5941,7 @@ An operator precedence parser. eq $P312, 66, loop310_redo loop310_done: pop_eh - for_undef_98: + for_undef_99: .annotate 'line', 137 set $P292, $P300 if_293_end: @@ -5875,7 +5951,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "_block304" :anon :subid("33_1275511694.5657") :outer("32_1275511694.5657") +.sub "_block304" :anon :subid("33_1275599992.78953") :outer("32_1275599992.78953") .param pmc param_306 .annotate 'line', 139 .lex "$_", param_306 @@ -5887,10 +5963,10 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "quote_delimited" :subid("34_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "quote_delimited" :subid("34_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_333 .annotate 'line', 152 - .const 'Sub' $P345 = "35_1275511694.5657" + .const 'Sub' $P345 = "35_1275599992.78953" capture_lex $P345 new $P332, 'ExceptionHandler' set_addr $P332, control_331 @@ -5915,15 +5991,15 @@ An operator precedence parser. store_lex "$lastlit", $P338 .annotate 'line', 155 find_lex $P340, "$/" - unless_null $P340, vivify_99 + unless_null $P340, vivify_100 $P340 = root_new ['parrot';'Hash'] - vivify_99: + vivify_100: set $P341, $P340["quote_atom"] - unless_null $P341, vivify_100 + unless_null $P341, vivify_101 new $P341, "Undef" - vivify_100: + vivify_101: defined $I342, $P341 - unless $I342, for_undef_101 + unless $I342, for_undef_102 iter $P339, $P341 new $P378, 'ExceptionHandler' set_addr $P378, loop377_handler @@ -5933,7 +6009,7 @@ An operator precedence parser. unless $P339, loop377_done shift $P343, $P339 loop377_redo: - .const 'Sub' $P345 = "35_1275511694.5657" + .const 'Sub' $P345 = "35_1275599992.78953" capture_lex $P345 $P345($P343) loop377_next: @@ -5946,7 +6022,7 @@ An operator precedence parser. eq $P379, 66, loop377_redo loop377_done: pop_eh - for_undef_101: + for_undef_102: .annotate 'line', 169 find_lex $P381, "$lastlit" set $S382, $P381 @@ -6011,7 +6087,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "_block344" :anon :subid("35_1275511694.5657") :outer("34_1275511694.5657") +.sub "_block344" :anon :subid("35_1275599992.78953") :outer("34_1275599992.78953") .param pmc param_347 .annotate 'line', 156 new $P346, "Undef" @@ -6080,7 +6156,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "quote_atom" :subid("36_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "quote_atom" :subid("36_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_408 .annotate 'line', 177 new $P407, 'ExceptionHandler' @@ -6092,13 +6168,13 @@ An operator precedence parser. .annotate 'line', 178 find_lex $P409, "$/" find_lex $P412, "$/" - unless_null $P412, vivify_102 + unless_null $P412, vivify_103 $P412 = root_new ['parrot';'Hash'] - vivify_102: + vivify_103: set $P413, $P412["quote_escape"] - unless_null $P413, vivify_103 + unless_null $P413, vivify_104 new $P413, "Undef" - vivify_103: + vivify_104: if $P413, if_411 find_lex $P417, "$/" set $S418, $P417 @@ -6107,13 +6183,13 @@ An operator precedence parser. goto if_411_end if_411: find_lex $P414, "$/" - unless_null $P414, vivify_104 + unless_null $P414, vivify_105 $P414 = root_new ['parrot';'Hash'] - vivify_104: + vivify_105: set $P415, $P414["quote_escape"] - unless_null $P415, vivify_105 + unless_null $P415, vivify_106 new $P415, "Undef" - vivify_105: + vivify_106: $P416 = $P415."ast"() set $P410, $P416 if_411_end: @@ -6129,7 +6205,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "quote_escape:sym" :subid("37_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "quote_escape:sym" :subid("37_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_424 .annotate 'line', 181 new $P423, 'ExceptionHandler' @@ -6150,7 +6226,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "quote_escape:sym" :subid("38_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "quote_escape:sym" :subid("38_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_431 .annotate 'line', 182 new $P430, 'ExceptionHandler' @@ -6161,13 +6237,13 @@ An operator precedence parser. .lex "$/", param_431 find_lex $P432, "$/" find_lex $P433, "$/" - unless_null $P433, vivify_106 + unless_null $P433, vivify_107 $P433 = root_new ['parrot';'Hash'] - vivify_106: + vivify_107: set $P434, $P433["stopper"] - unless_null $P434, vivify_107 + unless_null $P434, vivify_108 new $P434, "Undef" - vivify_107: + vivify_108: set $S435, $P434 $P436 = $P432."!make"($S435) .return ($P436) @@ -6180,7 +6256,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "quote_escape:sym" :subid("39_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "quote_escape:sym" :subid("39_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_441 .annotate 'line', 184 new $P440, 'ExceptionHandler' @@ -6201,7 +6277,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "quote_escape:sym" :subid("40_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "quote_escape:sym" :subid("40_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_448 .annotate 'line', 185 new $P447, 'ExceptionHandler' @@ -6222,7 +6298,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "quote_escape:sym" :subid("41_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "quote_escape:sym" :subid("41_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_455 .annotate 'line', 186 new $P454, 'ExceptionHandler' @@ -6243,7 +6319,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "quote_escape:sym" :subid("42_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "quote_escape:sym" :subid("42_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_462 .annotate 'line', 187 new $P461, 'ExceptionHandler' @@ -6264,7 +6340,7 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "quote_escape:sym" :subid("43_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "quote_escape:sym" :subid("43_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_469 .annotate 'line', 188 new $P468, 'ExceptionHandler' @@ -6285,169 +6361,167 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "quote_escape:sym" :subid("44_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "quote_escape:sym" :subid("44_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_476 -.annotate 'line', 190 +.annotate 'line', 189 new $P475, 'ExceptionHandler' set_addr $P475, control_474 $P475."handle_types"(57) push_eh $P475 .lex "self", self .lex "$/", param_476 -.annotate 'line', 191 find_lex $P477, "$/" - find_lex $P480, "$/" - unless_null $P480, vivify_108 - $P480 = root_new ['parrot';'Hash'] - vivify_108: - set $P481, $P480["hexint"] - unless_null $P481, vivify_109 - new $P481, "Undef" - vivify_109: - if $P481, if_479 + $P478 = $P477."!make"("\e") + .return ($P478) + control_474: + .local pmc exception + .get_results (exception) + getattribute $P479, exception, "payload" + .return ($P479) +.end + + +.namespace ["HLL";"Actions"] +.sub "quote_escape:sym" :subid("45_1275599992.78953") :method :outer("11_1275599992.78953") + .param pmc param_483 +.annotate 'line', 191 + new $P482, 'ExceptionHandler' + set_addr $P482, control_481 + $P482."handle_types"(57) + push_eh $P482 + .lex "self", self + .lex "$/", param_483 +.annotate 'line', 192 find_lex $P484, "$/" - unless_null $P484, vivify_110 - $P484 = root_new ['parrot';'Hash'] + find_lex $P487, "$/" + unless_null $P487, vivify_109 + $P487 = root_new ['parrot';'Hash'] + vivify_109: + set $P488, $P487["hexint"] + unless_null $P488, vivify_110 + new $P488, "Undef" vivify_110: - set $P485, $P484["hexints"] - unless_null $P485, vivify_111 - $P485 = root_new ['parrot';'Hash'] + if $P488, if_486 + find_lex $P491, "$/" + unless_null $P491, vivify_111 + $P491 = root_new ['parrot';'Hash'] vivify_111: - set $P486, $P485["hexint"] - unless_null $P486, vivify_112 - new $P486, "Undef" + set $P492, $P491["hexints"] + unless_null $P492, vivify_112 + $P492 = root_new ['parrot';'Hash'] vivify_112: - set $P478, $P486 - goto if_479_end - if_479: - find_lex $P482, "$/" - unless_null $P482, vivify_113 - $P482 = root_new ['parrot';'Hash'] + set $P493, $P492["hexint"] + unless_null $P493, vivify_113 + new $P493, "Undef" vivify_113: - set $P483, $P482["hexint"] - unless_null $P483, vivify_114 - new $P483, "Undef" + set $P485, $P493 + goto if_486_end + if_486: + find_lex $P489, "$/" + unless_null $P489, vivify_114 + $P489 = root_new ['parrot';'Hash'] vivify_114: - set $P478, $P483 - if_479_end: - $P487 = "ints_to_string"($P478) - $P488 = $P477."!make"($P487) -.annotate 'line', 190 - .return ($P488) - control_474: + set $P490, $P489["hexint"] + unless_null $P490, vivify_115 + new $P490, "Undef" + vivify_115: + set $P485, $P490 + if_486_end: + $P494 = "ints_to_string"($P485) + $P495 = $P484."!make"($P494) +.annotate 'line', 191 + .return ($P495) + control_481: .local pmc exception .get_results (exception) - getattribute $P489, exception, "payload" - .return ($P489) + getattribute $P496, exception, "payload" + .return ($P496) .end .namespace ["HLL";"Actions"] -.sub "quote_escape:sym" :subid("45_1275511694.5657") :method :outer("11_1275511694.5657") - .param pmc param_493 -.annotate 'line', 194 - new $P492, 'ExceptionHandler' - set_addr $P492, control_491 - $P492."handle_types"(57) - push_eh $P492 - .lex "self", self - .lex "$/", param_493 +.sub "quote_escape:sym" :subid("46_1275599992.78953") :method :outer("11_1275599992.78953") + .param pmc param_500 .annotate 'line', 195 - find_lex $P494, "$/" - find_lex $P497, "$/" - unless_null $P497, vivify_115 - $P497 = root_new ['parrot';'Hash'] - vivify_115: - set $P498, $P497["octint"] - unless_null $P498, vivify_116 - new $P498, "Undef" - vivify_116: - if $P498, if_496 + new $P499, 'ExceptionHandler' + set_addr $P499, control_498 + $P499."handle_types"(57) + push_eh $P499 + .lex "self", self + .lex "$/", param_500 +.annotate 'line', 196 find_lex $P501, "$/" - unless_null $P501, vivify_117 - $P501 = root_new ['parrot';'Hash'] + find_lex $P504, "$/" + unless_null $P504, vivify_116 + $P504 = root_new ['parrot';'Hash'] + vivify_116: + set $P505, $P504["octint"] + unless_null $P505, vivify_117 + new $P505, "Undef" vivify_117: - set $P502, $P501["octints"] - unless_null $P502, vivify_118 - $P502 = root_new ['parrot';'Hash'] + if $P505, if_503 + find_lex $P508, "$/" + unless_null $P508, vivify_118 + $P508 = root_new ['parrot';'Hash'] vivify_118: - set $P503, $P502["octint"] - unless_null $P503, vivify_119 - new $P503, "Undef" + set $P509, $P508["octints"] + unless_null $P509, vivify_119 + $P509 = root_new ['parrot';'Hash'] vivify_119: - set $P495, $P503 - goto if_496_end - if_496: - find_lex $P499, "$/" - unless_null $P499, vivify_120 - $P499 = root_new ['parrot';'Hash'] + set $P510, $P509["octint"] + unless_null $P510, vivify_120 + new $P510, "Undef" vivify_120: - set $P500, $P499["octint"] - unless_null $P500, vivify_121 - new $P500, "Undef" + set $P502, $P510 + goto if_503_end + if_503: + find_lex $P506, "$/" + unless_null $P506, vivify_121 + $P506 = root_new ['parrot';'Hash'] vivify_121: - set $P495, $P500 - if_496_end: - $P504 = "ints_to_string"($P495) - $P505 = $P494."!make"($P504) -.annotate 'line', 194 - .return ($P505) - control_491: - .local pmc exception - .get_results (exception) - getattribute $P506, exception, "payload" - .return ($P506) -.end - - -.namespace ["HLL";"Actions"] -.sub "quote_escape:sym" :subid("46_1275511694.5657") :method :outer("11_1275511694.5657") - .param pmc param_510 -.annotate 'line', 198 - new $P509, 'ExceptionHandler' - set_addr $P509, control_508 - $P509."handle_types"(57) - push_eh $P509 - .lex "self", self - .lex "$/", param_510 -.annotate 'line', 199 - find_lex $P511, "$/" - find_lex $P512, "$/" - unless_null $P512, vivify_122 - $P512 = root_new ['parrot';'Hash'] + set $P507, $P506["octint"] + unless_null $P507, vivify_122 + new $P507, "Undef" vivify_122: - set $P513, $P512["charspec"] - unless_null $P513, vivify_123 - new $P513, "Undef" - vivify_123: - $P514 = $P513."ast"() - $P515 = $P511."!make"($P514) -.annotate 'line', 198 - .return ($P515) - control_508: + set $P502, $P507 + if_503_end: + $P511 = "ints_to_string"($P502) + $P512 = $P501."!make"($P511) +.annotate 'line', 195 + .return ($P512) + control_498: .local pmc exception .get_results (exception) - getattribute $P516, exception, "payload" - .return ($P516) + getattribute $P513, exception, "payload" + .return ($P513) .end .namespace ["HLL";"Actions"] -.sub "quote_escape:sym<0>" :subid("47_1275511694.5657") :method :outer("11_1275511694.5657") - .param pmc param_520 -.annotate 'line', 202 - new $P519, 'ExceptionHandler' - set_addr $P519, control_518 - $P519."handle_types"(57) - push_eh $P519 +.sub "quote_escape:sym" :subid("47_1275599992.78953") :method :outer("11_1275599992.78953") + .param pmc param_517 +.annotate 'line', 199 + new $P516, 'ExceptionHandler' + set_addr $P516, control_515 + $P516."handle_types"(57) + push_eh $P516 .lex "self", self - .lex "$/", param_520 -.annotate 'line', 203 - find_lex $P521, "$/" - $P522 = $P521."!make"(unicode:"\x{0}") -.annotate 'line', 202 + .lex "$/", param_517 +.annotate 'line', 200 + find_lex $P518, "$/" + find_lex $P519, "$/" + unless_null $P519, vivify_123 + $P519 = root_new ['parrot';'Hash'] + vivify_123: + set $P520, $P519["charspec"] + unless_null $P520, vivify_124 + new $P520, "Undef" + vivify_124: + $P521 = $P520."ast"() + $P522 = $P518."!make"($P521) +.annotate 'line', 199 .return ($P522) - control_518: + control_515: .local pmc exception .get_results (exception) getattribute $P523, exception, "payload" @@ -6456,287 +6530,310 @@ An operator precedence parser. .namespace ["HLL";"Actions"] -.sub "quote_escape:sym" :subid("48_1275511694.5657") :method :outer("11_1275511694.5657") +.sub "quote_escape:sym<0>" :subid("48_1275599992.78953") :method :outer("11_1275599992.78953") .param pmc param_527 -.annotate 'line', 206 +.annotate 'line', 203 new $P526, 'ExceptionHandler' set_addr $P526, control_525 $P526."handle_types"(57) push_eh $P526 .lex "self", self .lex "$/", param_527 -.annotate 'line', 207 +.annotate 'line', 204 find_lex $P528, "$/" - find_lex $P531, "$/" - unless_null $P531, vivify_124 - $P531 = root_new ['parrot';'Hash'] - vivify_124: - set $P532, $P531["textq"] - unless_null $P532, vivify_125 - new $P532, "Undef" - vivify_125: - if $P532, if_530 + $P529 = $P528."!make"(unicode:"\x{0}") +.annotate 'line', 203 + .return ($P529) + control_525: + .local pmc exception + .get_results (exception) + getattribute $P530, exception, "payload" + .return ($P530) +.end + + +.namespace ["HLL";"Actions"] +.sub "quote_escape:sym" :subid("49_1275599992.78953") :method :outer("11_1275599992.78953") + .param pmc param_534 +.annotate 'line', 207 + new $P533, 'ExceptionHandler' + set_addr $P533, control_532 + $P533."handle_types"(57) + push_eh $P533 + .lex "self", self + .lex "$/", param_534 +.annotate 'line', 208 + find_lex $P535, "$/" find_lex $P538, "$/" - unless_null $P538, vivify_126 + unless_null $P538, vivify_125 $P538 = root_new ['parrot';'Hash'] - vivify_126: - set $P539, $P538["textqq"] - unless_null $P539, vivify_127 + vivify_125: + set $P539, $P538["textq"] + unless_null $P539, vivify_126 new $P539, "Undef" + vivify_126: + if $P539, if_537 + find_lex $P545, "$/" + unless_null $P545, vivify_127 + $P545 = root_new ['parrot';'Hash'] vivify_127: - $P540 = $P539."Str"() - set $P529, $P540 - goto if_530_end - if_530: - new $P533, "String" - assign $P533, "\\" - find_lex $P534, "$/" - unless_null $P534, vivify_128 - $P534 = root_new ['parrot';'Hash'] + set $P546, $P545["textqq"] + unless_null $P546, vivify_128 + new $P546, "Undef" vivify_128: - set $P535, $P534["textq"] - unless_null $P535, vivify_129 - new $P535, "Undef" + $P547 = $P546."Str"() + set $P536, $P547 + goto if_537_end + if_537: + new $P540, "String" + assign $P540, "\\" + find_lex $P541, "$/" + unless_null $P541, vivify_129 + $P541 = root_new ['parrot';'Hash'] vivify_129: - $S536 = $P535."Str"() - concat $P537, $P533, $S536 - set $P529, $P537 - if_530_end: - $P541 = $P528."!make"($P529) -.annotate 'line', 206 - .return ($P541) - control_525: + set $P542, $P541["textq"] + unless_null $P542, vivify_130 + new $P542, "Undef" + vivify_130: + $S543 = $P542."Str"() + concat $P544, $P540, $S543 + set $P536, $P544 + if_537_end: + $P548 = $P535."!make"($P536) +.annotate 'line', 207 + .return ($P548) + control_532: .local pmc exception .get_results (exception) - getattribute $P542, exception, "payload" - .return ($P542) + getattribute $P549, exception, "payload" + .return ($P549) .end .namespace ["HLL";"Actions"] -.sub "charname" :subid("49_1275511694.5657") :method :outer("11_1275511694.5657") - .param pmc param_546 -.annotate 'line', 210 - new $P545, 'ExceptionHandler' - set_addr $P545, control_544 - $P545."handle_types"(57) - push_eh $P545 - .lex "self", self - .lex "$/", param_546 +.sub "charname" :subid("50_1275599992.78953") :method :outer("11_1275599992.78953") + .param pmc param_553 .annotate 'line', 211 - new $P547, "Undef" - .lex "$codepoint", $P547 + new $P552, 'ExceptionHandler' + set_addr $P552, control_551 + $P552."handle_types"(57) + push_eh $P552 + .lex "self", self + .lex "$/", param_553 .annotate 'line', 212 - find_lex $P550, "$/" - unless_null $P550, vivify_130 - $P550 = root_new ['parrot';'Hash'] - vivify_130: - set $P551, $P550["integer"] - unless_null $P551, vivify_131 - new $P551, "Undef" - vivify_131: - if $P551, if_549 + new $P554, "Undef" + .lex "$codepoint", $P554 .annotate 'line', 213 - find_lex $P555, "$/" - set $S556, $P555 - find_codepoint $I557, $S556 - new $P548, 'Integer' - set $P548, $I557 -.annotate 'line', 212 - goto if_549_end - if_549: - find_lex $P552, "$/" - unless_null $P552, vivify_132 - $P552 = root_new ['parrot';'Hash'] + find_lex $P557, "$/" + unless_null $P557, vivify_131 + $P557 = root_new ['parrot';'Hash'] + vivify_131: + set $P558, $P557["integer"] + unless_null $P558, vivify_132 + new $P558, "Undef" vivify_132: - set $P553, $P552["integer"] - unless_null $P553, vivify_133 - new $P553, "Undef" - vivify_133: - $P554 = $P553."ast"() - set $P548, $P554 - if_549_end: - store_lex "$codepoint", $P548 + if $P558, if_556 .annotate 'line', 214 - find_lex $P559, "$codepoint" - set $N560, $P559 - islt $I561, $N560, 0.0 - unless $I561, if_558_end find_lex $P562, "$/" - $P563 = $P562."CURSOR"() - new $P564, 'String' - set $P564, "Unrecognized character name " - find_lex $P565, "$/" - concat $P566, $P564, $P565 - $P563."panic"($P566) - if_558_end: + set $S563, $P562 + find_codepoint $I564, $S563 + new $P555, 'Integer' + set $P555, $I564 +.annotate 'line', 213 + goto if_556_end + if_556: + find_lex $P559, "$/" + unless_null $P559, vivify_133 + $P559 = root_new ['parrot';'Hash'] + vivify_133: + set $P560, $P559["integer"] + unless_null $P560, vivify_134 + new $P560, "Undef" + vivify_134: + $P561 = $P560."ast"() + set $P555, $P561 + if_556_end: + store_lex "$codepoint", $P555 .annotate 'line', 215 - find_lex $P567, "$/" - find_lex $P568, "$codepoint" - set $I569, $P568 - chr $S570, $I569 - $P571 = $P567."!make"($S570) -.annotate 'line', 210 - .return ($P571) - control_544: + find_lex $P566, "$codepoint" + set $N567, $P566 + islt $I568, $N567, 0.0 + unless $I568, if_565_end + find_lex $P569, "$/" + $P570 = $P569."CURSOR"() + new $P571, 'String' + set $P571, "Unrecognized character name " + find_lex $P572, "$/" + concat $P573, $P571, $P572 + $P570."panic"($P573) + if_565_end: +.annotate 'line', 216 + find_lex $P574, "$/" + find_lex $P575, "$codepoint" + set $I576, $P575 + chr $S577, $I576 + $P578 = $P574."!make"($S577) +.annotate 'line', 211 + .return ($P578) + control_551: .local pmc exception .get_results (exception) - getattribute $P572, exception, "payload" - .return ($P572) + getattribute $P579, exception, "payload" + .return ($P579) .end .namespace ["HLL";"Actions"] -.sub "charnames" :subid("50_1275511694.5657") :method :outer("11_1275511694.5657") - .param pmc param_576 -.annotate 'line', 218 - .const 'Sub' $P585 = "51_1275511694.5657" - capture_lex $P585 - new $P575, 'ExceptionHandler' - set_addr $P575, control_574 - $P575."handle_types"(57) - push_eh $P575 - .lex "self", self - .lex "$/", param_576 +.sub "charnames" :subid("51_1275599992.78953") :method :outer("11_1275599992.78953") + .param pmc param_583 .annotate 'line', 219 - new $P577, "Undef" - .lex "$str", $P577 - new $P578, "String" - assign $P578, "" - store_lex "$str", $P578 + .const 'Sub' $P592 = "52_1275599992.78953" + capture_lex $P592 + new $P582, 'ExceptionHandler' + set_addr $P582, control_581 + $P582."handle_types"(57) + push_eh $P582 + .lex "self", self + .lex "$/", param_583 .annotate 'line', 220 - find_lex $P580, "$/" - unless_null $P580, vivify_134 - $P580 = root_new ['parrot';'Hash'] - vivify_134: - set $P581, $P580["charname"] - unless_null $P581, vivify_135 - new $P581, "Undef" + new $P584, "Undef" + .lex "$str", $P584 + new $P585, "String" + assign $P585, "" + store_lex "$str", $P585 +.annotate 'line', 221 + find_lex $P587, "$/" + unless_null $P587, vivify_135 + $P587 = root_new ['parrot';'Hash'] vivify_135: - defined $I582, $P581 - unless $I582, for_undef_136 - iter $P579, $P581 - new $P592, 'ExceptionHandler' - set_addr $P592, loop591_handler - $P592."handle_types"(64, 66, 65) - push_eh $P592 - loop591_test: - unless $P579, loop591_done - shift $P583, $P579 - loop591_redo: - .const 'Sub' $P585 = "51_1275511694.5657" - capture_lex $P585 - $P585($P583) - loop591_next: - goto loop591_test - loop591_handler: + set $P588, $P587["charname"] + unless_null $P588, vivify_136 + new $P588, "Undef" + vivify_136: + defined $I589, $P588 + unless $I589, for_undef_137 + iter $P586, $P588 + new $P599, 'ExceptionHandler' + set_addr $P599, loop598_handler + $P599."handle_types"(64, 66, 65) + push_eh $P599 + loop598_test: + unless $P586, loop598_done + shift $P590, $P586 + loop598_redo: + .const 'Sub' $P592 = "52_1275599992.78953" + capture_lex $P592 + $P592($P590) + loop598_next: + goto loop598_test + loop598_handler: .local pmc exception .get_results (exception) - getattribute $P593, exception, 'type' - eq $P593, 64, loop591_next - eq $P593, 66, loop591_redo - loop591_done: + getattribute $P600, exception, 'type' + eq $P600, 64, loop598_next + eq $P600, 66, loop598_redo + loop598_done: pop_eh - for_undef_136: -.annotate 'line', 221 - find_lex $P594, "$/" - find_lex $P595, "$str" - $P596 = $P594."!make"($P595) -.annotate 'line', 218 - .return ($P596) - control_574: + for_undef_137: +.annotate 'line', 222 + find_lex $P601, "$/" + find_lex $P602, "$str" + $P603 = $P601."!make"($P602) +.annotate 'line', 219 + .return ($P603) + control_581: .local pmc exception .get_results (exception) - getattribute $P597, exception, "payload" - .return ($P597) + getattribute $P604, exception, "payload" + .return ($P604) .end .namespace ["HLL";"Actions"] -.sub "_block584" :anon :subid("51_1275511694.5657") :outer("50_1275511694.5657") - .param pmc param_586 -.annotate 'line', 220 - .lex "$_", param_586 - find_lex $P587, "$str" - find_lex $P588, "$_" - $S589 = $P588."ast"() - concat $P590, $P587, $S589 - store_lex "$str", $P590 - .return ($P590) +.sub "_block591" :anon :subid("52_1275599992.78953") :outer("51_1275599992.78953") + .param pmc param_593 +.annotate 'line', 221 + .lex "$_", param_593 + find_lex $P594, "$str" + find_lex $P595, "$_" + $S596 = $P595."ast"() + concat $P597, $P594, $S596 + store_lex "$str", $P597 + .return ($P597) .end .namespace ["HLL";"Actions"] -.sub "charspec" :subid("52_1275511694.5657") :method :outer("11_1275511694.5657") - .param pmc param_601 -.annotate 'line', 224 - new $P600, 'ExceptionHandler' - set_addr $P600, control_599 - $P600."handle_types"(57) - push_eh $P600 - .lex "self", self - .lex "$/", param_601 +.sub "charspec" :subid("53_1275599992.78953") :method :outer("11_1275599992.78953") + .param pmc param_608 .annotate 'line', 225 - find_lex $P602, "$/" - find_lex $P605, "$/" - unless_null $P605, vivify_137 - $P605 = root_new ['parrot';'Hash'] - vivify_137: - set $P606, $P605["charnames"] - unless_null $P606, vivify_138 - new $P606, "Undef" + new $P607, 'ExceptionHandler' + set_addr $P607, control_606 + $P607."handle_types"(57) + push_eh $P607 + .lex "self", self + .lex "$/", param_608 +.annotate 'line', 226 + find_lex $P609, "$/" + find_lex $P612, "$/" + unless_null $P612, vivify_138 + $P612 = root_new ['parrot';'Hash'] vivify_138: - if $P606, if_604 - find_lex $P610, "$/" - $I611 = "string_to_int"($P610, 10) - chr $S612, $I611 - new $P603, 'String' - set $P603, $S612 - goto if_604_end - if_604: - find_lex $P607, "$/" - unless_null $P607, vivify_139 - $P607 = root_new ['parrot';'Hash'] + set $P613, $P612["charnames"] + unless_null $P613, vivify_139 + new $P613, "Undef" vivify_139: - set $P608, $P607["charnames"] - unless_null $P608, vivify_140 - new $P608, "Undef" + if $P613, if_611 + find_lex $P617, "$/" + $I618 = "string_to_int"($P617, 10) + chr $S619, $I618 + new $P610, 'String' + set $P610, $S619 + goto if_611_end + if_611: + find_lex $P614, "$/" + unless_null $P614, vivify_140 + $P614 = root_new ['parrot';'Hash'] vivify_140: - $P609 = $P608."ast"() - set $P603, $P609 - if_604_end: - $P613 = $P602."!make"($P603) -.annotate 'line', 224 - .return ($P613) - control_599: + set $P615, $P614["charnames"] + unless_null $P615, vivify_141 + new $P615, "Undef" + vivify_141: + $P616 = $P615."ast"() + set $P610, $P616 + if_611_end: + $P620 = $P609."!make"($P610) +.annotate 'line', 225 + .return ($P620) + control_606: .local pmc exception .get_results (exception) - getattribute $P614, exception, "payload" - .return ($P614) + getattribute $P621, exception, "payload" + .return ($P621) .end .namespace ["HLL";"Actions"] -.sub "_block616" :load :anon :subid("53_1275511694.5657") +.sub "_block623" :load :anon :subid("54_1275599992.78953") .annotate 'line', 3 - .const 'Sub' $P618 = "11_1275511694.5657" - $P619 = $P618() - .return ($P619) + .const 'Sub' $P625 = "11_1275599992.78953" + $P626 = $P625() + .return ($P626) .end .namespace [] -.sub "_block621" :load :anon :subid("54_1275511694.5657") +.sub "_block628" :load :anon :subid("55_1275599992.78953") .annotate 'line', 1 - .const 'Sub' $P623 = "10_1275511694.5657" - $P624 = $P623() - .return ($P624) + .const 'Sub' $P630 = "10_1275599992.78953" + $P631 = $P630() + .return ($P631) .end ### .include 'gen/hllcompiler.pir' .namespace [] -.sub "_block11" :anon :subid("10_1275511701.66626") +.sub "_block11" :anon :subid("10_1275599994.24334") .annotate 'line', 0 get_hll_global $P14, ["HLL";"Compiler"], "_block13" capture_lex $P14 @@ -6753,15 +6850,15 @@ An operator precedence parser. $P492 = $P14() .annotate 'line', 1 .return ($P492) - .const 'Sub' $P494 = "35_1275511701.66626" + .const 'Sub' $P494 = "35_1275599994.24334" .return ($P494) .end .namespace [] -.sub "" :load :init :subid("post36") :outer("10_1275511701.66626") +.sub "" :load :init :subid("post36") :outer("10_1275599994.24334") .annotate 'line', 0 - .const 'Sub' $P12 = "10_1275511701.66626" + .const 'Sub' $P12 = "10_1275599994.24334" .local pmc block set block, $P12 .annotate 'line', 2 @@ -6775,36 +6872,36 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block13" :subid("11_1275511701.66626") :outer("10_1275511701.66626") +.sub "_block13" :subid("11_1275599994.24334") :outer("10_1275599994.24334") .annotate 'line', 6 - .const 'Sub' $P484 = "34_1275511701.66626" + .const 'Sub' $P484 = "34_1275599994.24334" capture_lex $P484 - .const 'Sub' $P442 = "32_1275511701.66626" + .const 'Sub' $P442 = "32_1275599994.24334" capture_lex $P442 - .const 'Sub' $P298 = "26_1275511701.66626" + .const 'Sub' $P298 = "26_1275599994.24334" capture_lex $P298 - .const 'Sub' $P283 = "25_1275511701.66626" + .const 'Sub' $P283 = "25_1275599994.24334" capture_lex $P283 - .const 'Sub' $P188 = "20_1275511701.66626" + .const 'Sub' $P188 = "20_1275599994.24334" capture_lex $P188 - .const 'Sub' $P153 = "18_1275511701.66626" + .const 'Sub' $P153 = "18_1275599994.24334" capture_lex $P153 - .const 'Sub' $P138 = "17_1275511701.66626" + .const 'Sub' $P138 = "17_1275599994.24334" capture_lex $P138 - .const 'Sub' $P122 = "16_1275511701.66626" + .const 'Sub' $P122 = "16_1275599994.24334" capture_lex $P122 - .const 'Sub' $P33 = "13_1275511701.66626" + .const 'Sub' $P33 = "13_1275599994.24334" capture_lex $P33 - .const 'Sub' $P15 = "12_1275511701.66626" + .const 'Sub' $P15 = "12_1275599994.24334" capture_lex $P15 .annotate 'line', 14 - .const 'Sub' $P15 = "12_1275511701.66626" + .const 'Sub' $P15 = "12_1275599994.24334" newclosure $P31, $P15 .lex "value_type", $P31 .annotate 'line', 10 find_lex $P32, "value_type" .annotate 'line', 163 - .const 'Sub' $P484 = "34_1275511701.66626" + .const 'Sub' $P484 = "34_1275599994.24334" newclosure $P490, $P484 .annotate 'line', 6 .return ($P490) @@ -6812,7 +6909,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "" :load :init :subid("post37") :outer("11_1275511701.66626") +.sub "" :load :init :subid("post37") :outer("11_1275599994.24334") .annotate 'line', 6 get_hll_global $P14, ["HLL";"Compiler"], "_block13" .local pmc block @@ -6824,7 +6921,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "value_type" :subid("12_1275511701.66626") :outer("11_1275511701.66626") +.sub "value_type" :subid("12_1275599994.24334") :outer("11_1275599994.24334") .param pmc param_18 .annotate 'line', 14 new $P17, 'ExceptionHandler' @@ -6868,15 +6965,15 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "get_exports" :subid("13_1275511701.66626") :method :outer("11_1275511701.66626") +.sub "get_exports" :subid("13_1275599994.24334") :method :outer("11_1275599994.24334") .param pmc param_36 .param pmc param_39 :slurpy .param pmc param_37 :optional :named("tagset") .param int has_param_37 :opt_flag .annotate 'line', 20 - .const 'Sub' $P105 = "15_1275511701.66626" + .const 'Sub' $P105 = "15_1275599994.24334" capture_lex $P105 - .const 'Sub' $P84 = "14_1275511701.66626" + .const 'Sub' $P84 = "14_1275599994.24334" capture_lex $P84 new $P35, 'ExceptionHandler' set_addr $P35, control_34 @@ -6982,7 +7079,7 @@ An operator precedence parser. unless $P100, loop117_done shift $P103, $P100 loop117_redo: - .const 'Sub' $P105 = "15_1275511701.66626" + .const 'Sub' $P105 = "15_1275599994.24334" capture_lex $P105 $P105($P103) loop117_next: @@ -7012,7 +7109,7 @@ An operator precedence parser. unless $P79, loop97_done shift $P82, $P79 loop97_redo: - .const 'Sub' $P84 = "14_1275511701.66626" + .const 'Sub' $P84 = "14_1275599994.24334" capture_lex $P84 $P84($P82) loop97_next: @@ -7040,7 +7137,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block104" :anon :subid("15_1275511701.66626") :outer("13_1275511701.66626") +.sub "_block104" :anon :subid("15_1275599994.24334") :outer("13_1275599994.24334") .param pmc param_107 .annotate 'line', 40 new $P106, "Undef" @@ -7072,7 +7169,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block83" :anon :subid("14_1275511701.66626") :outer("13_1275511701.66626") +.sub "_block83" :anon :subid("14_1275599994.24334") :outer("13_1275599994.24334") .param pmc param_86 .annotate 'line', 34 new $P85, "Undef" @@ -7111,7 +7208,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "get_module" :subid("16_1275511701.66626") :method :outer("11_1275511701.66626") +.sub "get_module" :subid("16_1275599994.24334") :method :outer("11_1275599994.24334") .param pmc param_125 .annotate 'line', 47 new $P124, 'ExceptionHandler' @@ -7151,7 +7248,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "language" :subid("17_1275511701.66626") :method :outer("11_1275511701.66626") +.sub "language" :subid("17_1275599994.24334") :method :outer("11_1275599994.24334") .param pmc param_141 :optional .param int has_param_141 :opt_flag .annotate 'line', 53 @@ -7195,10 +7292,10 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "load_module" :subid("18_1275511701.66626") :method :outer("11_1275511701.66626") +.sub "load_module" :subid("18_1275599994.24334") :method :outer("11_1275599994.24334") .param pmc param_156 .annotate 'line', 61 - .const 'Sub' $P166 = "19_1275511701.66626" + .const 'Sub' $P166 = "19_1275599994.24334" capture_lex $P166 new $P155, 'ExceptionHandler' set_addr $P155, control_154 @@ -7225,7 +7322,7 @@ An operator precedence parser. assign $P164, 0 store_lex "$loaded", $P164 .annotate 'line', 64 - .const 'Sub' $P166 = "19_1275511701.66626" + .const 'Sub' $P166 = "19_1275599994.24334" capture_lex $P166 $P166() .annotate 'line', 65 @@ -7254,7 +7351,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block165" :anon :subid("19_1275511701.66626") :outer("18_1275511701.66626") +.sub "_block165" :anon :subid("19_1275599994.24334") :outer("18_1275599994.24334") .annotate 'line', 64 new $P173, 'ExceptionHandler' set_addr $P173, control_172 @@ -7287,11 +7384,11 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "import" :subid("20_1275511701.66626") :method :outer("11_1275511701.66626") +.sub "import" :subid("20_1275599994.24334") :method :outer("11_1275599994.24334") .param pmc param_191 .param pmc param_192 .annotate 'line', 69 - .const 'Sub' $P198 = "21_1275511701.66626" + .const 'Sub' $P198 = "21_1275599994.24334" capture_lex $P198 new $P190, 'ExceptionHandler' set_addr $P190, control_189 @@ -7313,7 +7410,7 @@ An operator precedence parser. unless $P193, loop279_done shift $P196, $P193 loop279_redo: - .const 'Sub' $P198 = "21_1275511701.66626" + .const 'Sub' $P198 = "21_1275599994.24334" capture_lex $P198 $P198($P196) loop279_next: @@ -7338,14 +7435,14 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block197" :anon :subid("21_1275511701.66626") :outer("20_1275511701.66626") +.sub "_block197" :anon :subid("21_1275599994.24334") :outer("20_1275599994.24334") .param pmc param_201 .annotate 'line', 70 - .const 'Sub' $P268 = "24_1275511701.66626" + .const 'Sub' $P268 = "24_1275599994.24334" capture_lex $P268 - .const 'Sub' $P248 = "23_1275511701.66626" + .const 'Sub' $P248 = "23_1275599994.24334" capture_lex $P248 - .const 'Sub' $P219 = "22_1275511701.66626" + .const 'Sub' $P219 = "22_1275599994.24334" capture_lex $P219 .annotate 'line', 71 new $P199, "Undef" @@ -7393,7 +7490,7 @@ An operator precedence parser. unless $P263, loop276_done shift $P266, $P263 loop276_redo: - .const 'Sub' $P268 = "24_1275511701.66626" + .const 'Sub' $P268 = "24_1275599994.24334" capture_lex $P268 $P268($P266) loop276_next: @@ -7425,7 +7522,7 @@ An operator precedence parser. unless $P243, loop260_done shift $P246, $P243 loop260_redo: - .const 'Sub' $P248 = "23_1275511701.66626" + .const 'Sub' $P248 = "23_1275599994.24334" capture_lex $P248 $P248($P246) loop260_next: @@ -7459,7 +7556,7 @@ An operator precedence parser. unless $P214, loop232_done shift $P217, $P214 loop232_redo: - .const 'Sub' $P219 = "22_1275511701.66626" + .const 'Sub' $P219 = "22_1275599994.24334" capture_lex $P219 $P219($P217) loop232_next: @@ -7482,7 +7579,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block267" :anon :subid("24_1275511701.66626") :outer("21_1275511701.66626") +.sub "_block267" :anon :subid("24_1275599994.24334") :outer("21_1275599994.24334") .param pmc param_269 .annotate 'line', 80 .lex "$_", param_269 @@ -7502,7 +7599,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block247" :anon :subid("23_1275511701.66626") :outer("21_1275511701.66626") +.sub "_block247" :anon :subid("23_1275599994.24334") :outer("21_1275599994.24334") .param pmc param_249 .annotate 'line', 77 .lex "$_", param_249 @@ -7522,7 +7619,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block218" :anon :subid("22_1275511701.66626") :outer("21_1275511701.66626") +.sub "_block218" :anon :subid("22_1275599994.24334") :outer("21_1275599994.24334") .param pmc param_220 .annotate 'line', 74 .lex "$_", param_220 @@ -7543,7 +7640,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "autoprint" :subid("25_1275511701.66626") :method :outer("11_1275511701.66626") +.sub "autoprint" :subid("25_1275599994.24334") :method :outer("11_1275599994.24334") .param pmc param_286 .annotate 'line', 85 new $P285, 'ExceptionHandler' @@ -7586,10 +7683,10 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "interactive" :subid("26_1275511701.66626") :method :outer("11_1275511701.66626") +.sub "interactive" :subid("26_1275599994.24334") :method :outer("11_1275599994.24334") .param pmc param_301 :slurpy :named .annotate 'line', 90 - .const 'Sub' $P331 = "27_1275511701.66626" + .const 'Sub' $P331 = "27_1275599994.24334" capture_lex $P331 new $P300, 'ExceptionHandler' set_addr $P300, control_299 @@ -7671,7 +7768,7 @@ An operator precedence parser. assign $P329, 1 unless $P329, loop438_done loop438_redo: - .const 'Sub' $P331 = "27_1275511701.66626" + .const 'Sub' $P331 = "27_1275599994.24334" capture_lex $P331 $P331() loop438_next: @@ -7695,9 +7792,9 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block330" :anon :subid("27_1275511701.66626") :outer("26_1275511701.66626") +.sub "_block330" :anon :subid("27_1275599994.24334") :outer("26_1275599994.24334") .annotate 'line', 101 - .const 'Sub' $P367 = "28_1275511701.66626" + .const 'Sub' $P367 = "28_1275599994.24334" capture_lex $P367 .annotate 'line', 104 new $P332, "Undef" @@ -7783,7 +7880,7 @@ An operator precedence parser. set $P363, $P365 goto if_364_end if_364: - .const 'Sub' $P367 = "28_1275511701.66626" + .const 'Sub' $P367 = "28_1275599994.24334" capture_lex $P367 $P437 = $P367() set $P363, $P437 @@ -7794,11 +7891,11 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block366" :anon :subid("28_1275511701.66626") :outer("27_1275511701.66626") +.sub "_block366" :anon :subid("28_1275599994.24334") :outer("27_1275599994.24334") .annotate 'line', 116 - .const 'Sub' $P405 = "31_1275511701.66626" + .const 'Sub' $P405 = "31_1275599994.24334" capture_lex $P405 - .const 'Sub' $P373 = "29_1275511701.66626" + .const 'Sub' $P373 = "29_1275599994.24334" capture_lex $P373 .annotate 'line', 118 new $P368, "Undef" @@ -7809,7 +7906,7 @@ An operator precedence parser. store_lex "$code", $P370 find_lex $P371, "$output" .annotate 'line', 119 - .const 'Sub' $P373 = "29_1275511701.66626" + .const 'Sub' $P373 = "29_1275599994.24334" capture_lex $P373 $P373() .annotate 'line', 126 @@ -7842,7 +7939,7 @@ An operator precedence parser. unless $P399, loop412_done shift $P403, $P399 loop412_redo: - .const 'Sub' $P405 = "31_1275511701.66626" + .const 'Sub' $P405 = "31_1275599994.24334" capture_lex $P405 $P405($P403) loop412_next: @@ -7908,9 +8005,9 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block372" :anon :subid("29_1275511701.66626") :outer("28_1275511701.66626") +.sub "_block372" :anon :subid("29_1275599994.24334") :outer("28_1275599994.24334") .annotate 'line', 119 - .const 'Sub' $P385 = "30_1275511701.66626" + .const 'Sub' $P385 = "30_1275599994.24334" capture_lex $P385 new $P381, 'ExceptionHandler' set_addr $P381, control_380 @@ -7930,7 +8027,7 @@ An operator precedence parser. .annotate 'line', 121 .local pmc exception .get_results (exception) - .const 'Sub' $P385 = "30_1275511701.66626" + .const 'Sub' $P385 = "30_1275599994.24334" newclosure $P393, $P385 $P393(exception) new $P394, 'Integer' @@ -7949,7 +8046,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block384" :anon :subid("30_1275511701.66626") :outer("29_1275511701.66626") +.sub "_block384" :anon :subid("30_1275599994.24334") :outer("29_1275599994.24334") .param pmc param_386 .annotate 'line', 121 .lex "$_", param_386 @@ -7973,7 +8070,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block404" :anon :subid("31_1275511701.66626") :outer("28_1275511701.66626") +.sub "_block404" :anon :subid("31_1275599994.24334") :outer("28_1275599994.24334") .param pmc param_406 .annotate 'line', 127 .lex "$_", param_406 @@ -7994,12 +8091,12 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "eval" :subid("32_1275511701.66626") :method :outer("11_1275511701.66626") +.sub "eval" :subid("32_1275599994.24334") :method :outer("11_1275599994.24334") .param pmc param_445 .param pmc param_446 :slurpy .param pmc param_447 :slurpy :named .annotate 'line', 144 - .const 'Sub' $P466 = "33_1275511701.66626" + .const 'Sub' $P466 = "33_1275599994.24334" capture_lex $P466 new $P444, 'ExceptionHandler' set_addr $P444, control_443 @@ -8046,7 +8143,7 @@ An operator precedence parser. set $P455, $I464 if_456_end: unless $P455, if_454_end - .const 'Sub' $P466 = "33_1275511701.66626" + .const 'Sub' $P466 = "33_1275599994.24334" capture_lex $P466 $P466() if_454_end: @@ -8063,7 +8160,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "_block465" :anon :subid("33_1275511701.66626") :outer("32_1275511701.66626") +.sub "_block465" :anon :subid("33_1275599994.24334") :outer("32_1275599994.24334") .annotate 'line', 150 new $P467, "Undef" .lex "$outer_ctx", $P467 @@ -8116,7 +8213,7 @@ An operator precedence parser. .namespace ["HLL";"Compiler"] -.sub "ctxsave" :subid("34_1275511701.66626") :method :outer("11_1275511701.66626") +.sub "ctxsave" :subid("34_1275599994.24334") :method :outer("11_1275599994.24334") .annotate 'line', 163 new $P486, 'ExceptionHandler' set_addr $P486, control_485 @@ -8144,9 +8241,9 @@ An operator precedence parser. .namespace [] -.sub "_block493" :load :anon :subid("35_1275511701.66626") +.sub "_block493" :load :anon :subid("35_1275599994.24334") .annotate 'line', 1 - .const 'Sub' $P495 = "10_1275511701.66626" + .const 'Sub' $P495 = "10_1275599994.24334" $P496 = $P495() .return ($P496) .end diff --git a/src/stage0/NQP-s0.pir b/src/stage0/NQP-s0.pir index 1d6a479..7f9920b 100644 --- a/src/stage0/NQP-s0.pir +++ b/src/stage0/NQP-s0.pir @@ -15,7 +15,7 @@ NQP::Compiler - NQP compiler ### .include 'gen/nqp-grammar.pir' .namespace [] -.sub "_block11" :anon :subid("10_1275511697.61926") +.sub "_block11" :anon :subid("10_1275600007.84296") .annotate 'line', 0 get_hll_global $P14, ["NQP";"Grammar"], "_block13" capture_lex $P14 @@ -29,327 +29,333 @@ NQP::Compiler - NQP compiler .annotate 'line', 4 get_hll_global $P14, ["NQP";"Grammar"], "_block13" capture_lex $P14 - $P1379 = $P14() + $P1408 = $P14() .annotate 'line', 1 - .return ($P1379) - .const 'Sub' $P1381 = "354_1275511697.61926" - .return ($P1381) + .return ($P1408) + .const 'Sub' $P1410 = "363_1275600007.84296" + .return ($P1410) .end .namespace [] -.sub "" :load :init :subid("post355") :outer("10_1275511697.61926") +.sub "" :load :init :subid("post364") :outer("10_1275600007.84296") .annotate 'line', 0 - .const 'Sub' $P12 = "10_1275511697.61926" + .const 'Sub' $P12 = "10_1275600007.84296" .local pmc block set block, $P12 - $P1384 = get_root_global ["parrot"], "P6metaclass" - $P1384."new_class"("NQP::Grammar", "HLL::Grammar" :named("parent")) -.end - - -.namespace ["NQP";"Grammar"] -.sub "_block13" :subid("11_1275511697.61926") :outer("10_1275511697.61926") -.annotate 'line', 4 - get_hll_global $P1295, ["NQP";"Regex"], "_block1294" - capture_lex $P1295 - .const 'Sub' $P1281 = "331_1275511697.61926" - capture_lex $P1281 - .const 'Sub' $P1275 = "329_1275511697.61926" - capture_lex $P1275 - .const 'Sub' $P1269 = "327_1275511697.61926" - capture_lex $P1269 - .const 'Sub' $P1263 = "325_1275511697.61926" - capture_lex $P1263 - .const 'Sub' $P1257 = "323_1275511697.61926" - capture_lex $P1257 - .const 'Sub' $P1251 = "321_1275511697.61926" - capture_lex $P1251 - .const 'Sub' $P1244 = "319_1275511697.61926" - capture_lex $P1244 - .const 'Sub' $P1237 = "317_1275511697.61926" - capture_lex $P1237 - .const 'Sub' $P1230 = "315_1275511697.61926" - capture_lex $P1230 - .const 'Sub' $P1223 = "313_1275511697.61926" - capture_lex $P1223 - .const 'Sub' $P1217 = "311_1275511697.61926" - capture_lex $P1217 - .const 'Sub' $P1210 = "309_1275511697.61926" - capture_lex $P1210 - .const 'Sub' $P1203 = "307_1275511697.61926" - capture_lex $P1203 - .const 'Sub' $P1196 = "305_1275511697.61926" - capture_lex $P1196 - .const 'Sub' $P1189 = "303_1275511697.61926" - capture_lex $P1189 - .const 'Sub' $P1182 = "301_1275511697.61926" - capture_lex $P1182 - .const 'Sub' $P1175 = "299_1275511697.61926" - capture_lex $P1175 - .const 'Sub' $P1168 = "297_1275511697.61926" - capture_lex $P1168 - .const 'Sub' $P1161 = "295_1275511697.61926" - capture_lex $P1161 - .const 'Sub' $P1154 = "293_1275511697.61926" - capture_lex $P1154 - .const 'Sub' $P1147 = "291_1275511697.61926" - capture_lex $P1147 - .const 'Sub' $P1140 = "289_1275511697.61926" - capture_lex $P1140 - .const 'Sub' $P1133 = "287_1275511697.61926" - capture_lex $P1133 - .const 'Sub' $P1126 = "285_1275511697.61926" - capture_lex $P1126 - .const 'Sub' $P1119 = "283_1275511697.61926" - capture_lex $P1119 - .const 'Sub' $P1112 = "281_1275511697.61926" - capture_lex $P1112 - .const 'Sub' $P1105 = "279_1275511697.61926" - capture_lex $P1105 - .const 'Sub' $P1098 = "277_1275511697.61926" - capture_lex $P1098 - .const 'Sub' $P1091 = "275_1275511697.61926" - capture_lex $P1091 - .const 'Sub' $P1084 = "273_1275511697.61926" - capture_lex $P1084 - .const 'Sub' $P1077 = "271_1275511697.61926" - capture_lex $P1077 - .const 'Sub' $P1070 = "269_1275511697.61926" - capture_lex $P1070 - .const 'Sub' $P1063 = "267_1275511697.61926" - capture_lex $P1063 - .const 'Sub' $P1056 = "265_1275511697.61926" - capture_lex $P1056 - .const 'Sub' $P1049 = "263_1275511697.61926" - capture_lex $P1049 - .const 'Sub' $P1042 = "261_1275511697.61926" - capture_lex $P1042 - .const 'Sub' $P1035 = "259_1275511697.61926" - capture_lex $P1035 - .const 'Sub' $P1029 = "257_1275511697.61926" - capture_lex $P1029 - .const 'Sub' $P1022 = "255_1275511697.61926" - capture_lex $P1022 - .const 'Sub' $P1015 = "253_1275511697.61926" - capture_lex $P1015 - .const 'Sub' $P1008 = "251_1275511697.61926" - capture_lex $P1008 - .const 'Sub' $P1001 = "249_1275511697.61926" - capture_lex $P1001 - .const 'Sub' $P994 = "247_1275511697.61926" - capture_lex $P994 - .const 'Sub' $P987 = "245_1275511697.61926" - capture_lex $P987 - .const 'Sub' $P980 = "243_1275511697.61926" + $P1413 = get_root_global ["parrot"], "P6metaclass" + $P1413."new_class"("NQP::Grammar", "HLL::Grammar" :named("parent")) +.end + + +.namespace ["NQP";"Grammar"] +.sub "_block13" :subid("11_1275600007.84296") :outer("10_1275600007.84296") +.annotate 'line', 4 + get_hll_global $P1324, ["NQP";"Regex"], "_block1323" + capture_lex $P1324 + .const 'Sub' $P1310 = "340_1275600007.84296" + capture_lex $P1310 + .const 'Sub' $P1304 = "338_1275600007.84296" + capture_lex $P1304 + .const 'Sub' $P1298 = "336_1275600007.84296" + capture_lex $P1298 + .const 'Sub' $P1292 = "334_1275600007.84296" + capture_lex $P1292 + .const 'Sub' $P1286 = "332_1275600007.84296" + capture_lex $P1286 + .const 'Sub' $P1280 = "330_1275600007.84296" + capture_lex $P1280 + .const 'Sub' $P1273 = "328_1275600007.84296" + capture_lex $P1273 + .const 'Sub' $P1266 = "326_1275600007.84296" + capture_lex $P1266 + .const 'Sub' $P1259 = "324_1275600007.84296" + capture_lex $P1259 + .const 'Sub' $P1252 = "322_1275600007.84296" + capture_lex $P1252 + .const 'Sub' $P1246 = "320_1275600007.84296" + capture_lex $P1246 + .const 'Sub' $P1239 = "318_1275600007.84296" + capture_lex $P1239 + .const 'Sub' $P1232 = "316_1275600007.84296" + capture_lex $P1232 + .const 'Sub' $P1225 = "314_1275600007.84296" + capture_lex $P1225 + .const 'Sub' $P1218 = "312_1275600007.84296" + capture_lex $P1218 + .const 'Sub' $P1211 = "310_1275600007.84296" + capture_lex $P1211 + .const 'Sub' $P1204 = "308_1275600007.84296" + capture_lex $P1204 + .const 'Sub' $P1197 = "306_1275600007.84296" + capture_lex $P1197 + .const 'Sub' $P1190 = "304_1275600007.84296" + capture_lex $P1190 + .const 'Sub' $P1183 = "302_1275600007.84296" + capture_lex $P1183 + .const 'Sub' $P1176 = "300_1275600007.84296" + capture_lex $P1176 + .const 'Sub' $P1169 = "298_1275600007.84296" + capture_lex $P1169 + .const 'Sub' $P1162 = "296_1275600007.84296" + capture_lex $P1162 + .const 'Sub' $P1155 = "294_1275600007.84296" + capture_lex $P1155 + .const 'Sub' $P1148 = "292_1275600007.84296" + capture_lex $P1148 + .const 'Sub' $P1141 = "290_1275600007.84296" + capture_lex $P1141 + .const 'Sub' $P1134 = "288_1275600007.84296" + capture_lex $P1134 + .const 'Sub' $P1127 = "286_1275600007.84296" + capture_lex $P1127 + .const 'Sub' $P1120 = "284_1275600007.84296" + capture_lex $P1120 + .const 'Sub' $P1113 = "282_1275600007.84296" + capture_lex $P1113 + .const 'Sub' $P1106 = "280_1275600007.84296" + capture_lex $P1106 + .const 'Sub' $P1099 = "278_1275600007.84296" + capture_lex $P1099 + .const 'Sub' $P1092 = "276_1275600007.84296" + capture_lex $P1092 + .const 'Sub' $P1085 = "274_1275600007.84296" + capture_lex $P1085 + .const 'Sub' $P1078 = "272_1275600007.84296" + capture_lex $P1078 + .const 'Sub' $P1071 = "270_1275600007.84296" + capture_lex $P1071 + .const 'Sub' $P1064 = "268_1275600007.84296" + capture_lex $P1064 + .const 'Sub' $P1058 = "266_1275600007.84296" + capture_lex $P1058 + .const 'Sub' $P1051 = "264_1275600007.84296" + capture_lex $P1051 + .const 'Sub' $P1044 = "262_1275600007.84296" + capture_lex $P1044 + .const 'Sub' $P1037 = "260_1275600007.84296" + capture_lex $P1037 + .const 'Sub' $P1030 = "258_1275600007.84296" + capture_lex $P1030 + .const 'Sub' $P1023 = "256_1275600007.84296" + capture_lex $P1023 + .const 'Sub' $P1016 = "254_1275600007.84296" + capture_lex $P1016 + .const 'Sub' $P1009 = "252_1275600007.84296" + capture_lex $P1009 + .const 'Sub' $P1003 = "250_1275600007.84296" + capture_lex $P1003 + .const 'Sub' $P997 = "248_1275600007.84296" + capture_lex $P997 + .const 'Sub' $P992 = "246_1275600007.84296" + capture_lex $P992 + .const 'Sub' $P986 = "244_1275600007.84296" + capture_lex $P986 + .const 'Sub' $P980 = "242_1275600007.84296" capture_lex $P980 - .const 'Sub' $P974 = "241_1275511697.61926" - capture_lex $P974 - .const 'Sub' $P968 = "239_1275511697.61926" - capture_lex $P968 - .const 'Sub' $P963 = "237_1275511697.61926" + .const 'Sub' $P975 = "240_1275600007.84296" + capture_lex $P975 + .const 'Sub' $P970 = "238_1275600007.84296" + capture_lex $P970 + .const 'Sub' $P963 = "236_1275600007.84296" capture_lex $P963 - .const 'Sub' $P957 = "235_1275511697.61926" - capture_lex $P957 - .const 'Sub' $P951 = "233_1275511697.61926" - capture_lex $P951 - .const 'Sub' $P946 = "231_1275511697.61926" - capture_lex $P946 - .const 'Sub' $P941 = "229_1275511697.61926" - capture_lex $P941 - .const 'Sub' $P934 = "227_1275511697.61926" - capture_lex $P934 - .const 'Sub' $P926 = "225_1275511697.61926" - capture_lex $P926 - .const 'Sub' $P921 = "223_1275511697.61926" - capture_lex $P921 - .const 'Sub' $P916 = "221_1275511697.61926" - capture_lex $P916 - .const 'Sub' $P911 = "219_1275511697.61926" - capture_lex $P911 - .const 'Sub' $P903 = "217_1275511697.61926" + .const 'Sub' $P955 = "234_1275600007.84296" + capture_lex $P955 + .const 'Sub' $P950 = "232_1275600007.84296" + capture_lex $P950 + .const 'Sub' $P945 = "230_1275600007.84296" + capture_lex $P945 + .const 'Sub' $P940 = "228_1275600007.84296" + capture_lex $P940 + .const 'Sub' $P932 = "226_1275600007.84296" + capture_lex $P932 + .const 'Sub' $P924 = "224_1275600007.84296" + capture_lex $P924 + .const 'Sub' $P919 = "222_1275600007.84296" + capture_lex $P919 + .const 'Sub' $P914 = "220_1275600007.84296" + capture_lex $P914 + .const 'Sub' $P909 = "218_1275600007.84296" + capture_lex $P909 + .const 'Sub' $P903 = "216_1275600007.84296" capture_lex $P903 - .const 'Sub' $P895 = "215_1275511697.61926" - capture_lex $P895 - .const 'Sub' $P890 = "213_1275511697.61926" - capture_lex $P890 - .const 'Sub' $P885 = "211_1275511697.61926" + .const 'Sub' $P897 = "214_1275600007.84296" + capture_lex $P897 + .const 'Sub' $P891 = "212_1275600007.84296" + capture_lex $P891 + .const 'Sub' $P885 = "210_1275600007.84296" capture_lex $P885 - .const 'Sub' $P880 = "209_1275511697.61926" - capture_lex $P880 - .const 'Sub' $P874 = "207_1275511697.61926" + .const 'Sub' $P879 = "208_1275600007.84296" + capture_lex $P879 + .const 'Sub' $P874 = "206_1275600007.84296" capture_lex $P874 - .const 'Sub' $P868 = "205_1275511697.61926" - capture_lex $P868 - .const 'Sub' $P862 = "203_1275511697.61926" - capture_lex $P862 - .const 'Sub' $P856 = "201_1275511697.61926" + .const 'Sub' $P869 = "204_1275600007.84296" + capture_lex $P869 + .const 'Sub' $P856 = "200_1275600007.84296" capture_lex $P856 - .const 'Sub' $P850 = "199_1275511697.61926" - capture_lex $P850 - .const 'Sub' $P845 = "197_1275511697.61926" - capture_lex $P845 - .const 'Sub' $P840 = "195_1275511697.61926" - capture_lex $P840 - .const 'Sub' $P827 = "191_1275511697.61926" - capture_lex $P827 - .const 'Sub' $P819 = "189_1275511697.61926" - capture_lex $P819 - .const 'Sub' $P813 = "187_1275511697.61926" + .const 'Sub' $P848 = "198_1275600007.84296" + capture_lex $P848 + .const 'Sub' $P842 = "196_1275600007.84296" + capture_lex $P842 + .const 'Sub' $P835 = "194_1275600007.84296" + capture_lex $P835 + .const 'Sub' $P829 = "192_1275600007.84296" + capture_lex $P829 + .const 'Sub' $P821 = "190_1275600007.84296" + capture_lex $P821 + .const 'Sub' $P813 = "188_1275600007.84296" capture_lex $P813 - .const 'Sub' $P806 = "185_1275511697.61926" - capture_lex $P806 - .const 'Sub' $P800 = "183_1275511697.61926" - capture_lex $P800 - .const 'Sub' $P792 = "181_1275511697.61926" - capture_lex $P792 - .const 'Sub' $P784 = "179_1275511697.61926" - capture_lex $P784 - .const 'Sub' $P778 = "177_1275511697.61926" - capture_lex $P778 - .const 'Sub' $P772 = "175_1275511697.61926" - capture_lex $P772 - .const 'Sub' $P757 = "171_1275511697.61926" - capture_lex $P757 - .const 'Sub' $P720 = "169_1275511697.61926" - capture_lex $P720 - .const 'Sub' $P712 = "167_1275511697.61926" - capture_lex $P712 - .const 'Sub' $P706 = "165_1275511697.61926" - capture_lex $P706 - .const 'Sub' $P696 = "163_1275511697.61926" - capture_lex $P696 - .const 'Sub' $P682 = "161_1275511697.61926" - capture_lex $P682 - .const 'Sub' $P673 = "159_1275511697.61926" - capture_lex $P673 - .const 'Sub' $P654 = "157_1275511697.61926" - capture_lex $P654 - .const 'Sub' $P630 = "155_1275511697.61926" - capture_lex $P630 - .const 'Sub' $P623 = "153_1275511697.61926" - capture_lex $P623 - .const 'Sub' $P616 = "151_1275511697.61926" - capture_lex $P616 - .const 'Sub' $P606 = "147_1275511697.61926" - capture_lex $P606 - .const 'Sub' $P598 = "145_1275511697.61926" - capture_lex $P598 - .const 'Sub' $P592 = "143_1275511697.61926" - capture_lex $P592 - .const 'Sub' $P578 = "141_1275511697.61926" - capture_lex $P578 - .const 'Sub' $P571 = "139_1275511697.61926" - capture_lex $P571 - .const 'Sub' $P564 = "137_1275511697.61926" - capture_lex $P564 - .const 'Sub' $P557 = "135_1275511697.61926" - capture_lex $P557 - .const 'Sub' $P530 = "131_1275511697.61926" - capture_lex $P530 - .const 'Sub' $P521 = "129_1275511697.61926" - capture_lex $P521 - .const 'Sub' $P514 = "127_1275511697.61926" - capture_lex $P514 - .const 'Sub' $P505 = "123_1275511697.61926" - capture_lex $P505 - .const 'Sub' $P500 = "121_1275511697.61926" + .const 'Sub' $P807 = "186_1275600007.84296" + capture_lex $P807 + .const 'Sub' $P801 = "184_1275600007.84296" + capture_lex $P801 + .const 'Sub' $P786 = "180_1275600007.84296" + capture_lex $P786 + .const 'Sub' $P749 = "178_1275600007.84296" + capture_lex $P749 + .const 'Sub' $P741 = "176_1275600007.84296" + capture_lex $P741 + .const 'Sub' $P735 = "174_1275600007.84296" + capture_lex $P735 + .const 'Sub' $P725 = "172_1275600007.84296" + capture_lex $P725 + .const 'Sub' $P711 = "170_1275600007.84296" + capture_lex $P711 + .const 'Sub' $P702 = "168_1275600007.84296" + capture_lex $P702 + .const 'Sub' $P695 = "166_1275600007.84296" + capture_lex $P695 + .const 'Sub' $P686 = "164_1275600007.84296" + capture_lex $P686 + .const 'Sub' $P663 = "160_1275600007.84296" + capture_lex $P663 + .const 'Sub' $P639 = "158_1275600007.84296" + capture_lex $P639 + .const 'Sub' $P632 = "156_1275600007.84296" + capture_lex $P632 + .const 'Sub' $P625 = "154_1275600007.84296" + capture_lex $P625 + .const 'Sub' $P615 = "150_1275600007.84296" + capture_lex $P615 + .const 'Sub' $P607 = "148_1275600007.84296" + capture_lex $P607 + .const 'Sub' $P601 = "146_1275600007.84296" + capture_lex $P601 + .const 'Sub' $P590 = "144_1275600007.84296" + capture_lex $P590 + .const 'Sub' $P583 = "142_1275600007.84296" + capture_lex $P583 + .const 'Sub' $P576 = "140_1275600007.84296" + capture_lex $P576 + .const 'Sub' $P569 = "138_1275600007.84296" + capture_lex $P569 + .const 'Sub' $P542 = "134_1275600007.84296" + capture_lex $P542 + .const 'Sub' $P533 = "132_1275600007.84296" + capture_lex $P533 + .const 'Sub' $P526 = "130_1275600007.84296" + capture_lex $P526 + .const 'Sub' $P517 = "126_1275600007.84296" + capture_lex $P517 + .const 'Sub' $P512 = "124_1275600007.84296" + capture_lex $P512 + .const 'Sub' $P500 = "122_1275600007.84296" capture_lex $P500 - .const 'Sub' $P488 = "119_1275511697.61926" + .const 'Sub' $P488 = "120_1275600007.84296" capture_lex $P488 - .const 'Sub' $P476 = "117_1275511697.61926" - capture_lex $P476 - .const 'Sub' $P468 = "115_1275511697.61926" - capture_lex $P468 - .const 'Sub' $P463 = "113_1275511697.61926" + .const 'Sub' $P480 = "118_1275600007.84296" + capture_lex $P480 + .const 'Sub' $P475 = "116_1275600007.84296" + capture_lex $P475 + .const 'Sub' $P469 = "114_1275600007.84296" + capture_lex $P469 + .const 'Sub' $P463 = "112_1275600007.84296" capture_lex $P463 - .const 'Sub' $P457 = "111_1275511697.61926" - capture_lex $P457 - .const 'Sub' $P451 = "109_1275511697.61926" - capture_lex $P451 - .const 'Sub' $P445 = "107_1275511697.61926" - capture_lex $P445 - .const 'Sub' $P439 = "105_1275511697.61926" - capture_lex $P439 - .const 'Sub' $P433 = "103_1275511697.61926" - capture_lex $P433 - .const 'Sub' $P427 = "101_1275511697.61926" - capture_lex $P427 - .const 'Sub' $P421 = "99_1275511697.61926" - capture_lex $P421 - .const 'Sub' $P415 = "97_1275511697.61926" - capture_lex $P415 - .const 'Sub' $P407 = "95_1275511697.61926" - capture_lex $P407 - .const 'Sub' $P399 = "93_1275511697.61926" - capture_lex $P399 - .const 'Sub' $P387 = "89_1275511697.61926" - capture_lex $P387 - .const 'Sub' $P379 = "87_1275511697.61926" - capture_lex $P379 - .const 'Sub' $P369 = "83_1275511697.61926" - capture_lex $P369 - .const 'Sub' $P362 = "81_1275511697.61926" - capture_lex $P362 - .const 'Sub' $P355 = "79_1275511697.61926" - capture_lex $P355 - .const 'Sub' $P343 = "75_1275511697.61926" - capture_lex $P343 - .const 'Sub' $P335 = "73_1275511697.61926" - capture_lex $P335 - .const 'Sub' $P327 = "71_1275511697.61926" - capture_lex $P327 - .const 'Sub' $P307 = "69_1275511697.61926" - capture_lex $P307 - .const 'Sub' $P298 = "67_1275511697.61926" - capture_lex $P298 - .const 'Sub' $P280 = "64_1275511697.61926" - capture_lex $P280 - .const 'Sub' $P260 = "62_1275511697.61926" - capture_lex $P260 - .const 'Sub' $P251 = "58_1275511697.61926" - capture_lex $P251 - .const 'Sub' $P246 = "56_1275511697.61926" - capture_lex $P246 - .const 'Sub' $P237 = "52_1275511697.61926" - capture_lex $P237 - .const 'Sub' $P232 = "50_1275511697.61926" - capture_lex $P232 - .const 'Sub' $P227 = "48_1275511697.61926" - capture_lex $P227 - .const 'Sub' $P219 = "46_1275511697.61926" - capture_lex $P219 - .const 'Sub' $P212 = "44_1275511697.61926" - capture_lex $P212 - .const 'Sub' $P206 = "42_1275511697.61926" - capture_lex $P206 - .const 'Sub' $P198 = "40_1275511697.61926" - capture_lex $P198 - .const 'Sub' $P192 = "38_1275511697.61926" - capture_lex $P192 - .const 'Sub' $P186 = "36_1275511697.61926" - capture_lex $P186 - .const 'Sub' $P170 = "33_1275511697.61926" - capture_lex $P170 - .const 'Sub' $P157 = "31_1275511697.61926" - capture_lex $P157 - .const 'Sub' $P150 = "29_1275511697.61926" - capture_lex $P150 - .const 'Sub' $P100 = "26_1275511697.61926" - capture_lex $P100 - .const 'Sub' $P82 = "23_1275511697.61926" - capture_lex $P82 - .const 'Sub' $P68 = "21_1275511697.61926" - capture_lex $P68 - .const 'Sub' $P54 = "19_1275511697.61926" - capture_lex $P54 - .const 'Sub' $P46 = "17_1275511697.61926" - capture_lex $P46 - .const 'Sub' $P39 = "15_1275511697.61926" - capture_lex $P39 - .const 'Sub' $P33 = "13_1275511697.61926" - capture_lex $P33 - .const 'Sub' $P15 = "12_1275511697.61926" + .const 'Sub' $P453 = "109_1275600007.84296" + capture_lex $P453 + .const 'Sub' $P447 = "107_1275600007.84296" + capture_lex $P447 + .const 'Sub' $P441 = "105_1275600007.84296" + capture_lex $P441 + .const 'Sub' $P435 = "103_1275600007.84296" + capture_lex $P435 + .const 'Sub' $P429 = "101_1275600007.84296" + capture_lex $P429 + .const 'Sub' $P423 = "99_1275600007.84296" + capture_lex $P423 + .const 'Sub' $P417 = "97_1275600007.84296" + capture_lex $P417 + .const 'Sub' $P409 = "95_1275600007.84296" + capture_lex $P409 + .const 'Sub' $P401 = "93_1275600007.84296" + capture_lex $P401 + .const 'Sub' $P389 = "89_1275600007.84296" + capture_lex $P389 + .const 'Sub' $P381 = "87_1275600007.84296" + capture_lex $P381 + .const 'Sub' $P371 = "83_1275600007.84296" + capture_lex $P371 + .const 'Sub' $P364 = "81_1275600007.84296" + capture_lex $P364 + .const 'Sub' $P357 = "79_1275600007.84296" + capture_lex $P357 + .const 'Sub' $P345 = "75_1275600007.84296" + capture_lex $P345 + .const 'Sub' $P337 = "73_1275600007.84296" + capture_lex $P337 + .const 'Sub' $P329 = "71_1275600007.84296" + capture_lex $P329 + .const 'Sub' $P309 = "69_1275600007.84296" + capture_lex $P309 + .const 'Sub' $P300 = "67_1275600007.84296" + capture_lex $P300 + .const 'Sub' $P282 = "64_1275600007.84296" + capture_lex $P282 + .const 'Sub' $P262 = "62_1275600007.84296" + capture_lex $P262 + .const 'Sub' $P253 = "58_1275600007.84296" + capture_lex $P253 + .const 'Sub' $P248 = "56_1275600007.84296" + capture_lex $P248 + .const 'Sub' $P239 = "52_1275600007.84296" + capture_lex $P239 + .const 'Sub' $P234 = "50_1275600007.84296" + capture_lex $P234 + .const 'Sub' $P229 = "48_1275600007.84296" + capture_lex $P229 + .const 'Sub' $P221 = "46_1275600007.84296" + capture_lex $P221 + .const 'Sub' $P214 = "44_1275600007.84296" + capture_lex $P214 + .const 'Sub' $P208 = "42_1275600007.84296" + capture_lex $P208 + .const 'Sub' $P200 = "40_1275600007.84296" + capture_lex $P200 + .const 'Sub' $P194 = "38_1275600007.84296" + capture_lex $P194 + .const 'Sub' $P188 = "36_1275600007.84296" + capture_lex $P188 + .const 'Sub' $P172 = "33_1275600007.84296" + capture_lex $P172 + .const 'Sub' $P159 = "31_1275600007.84296" + capture_lex $P159 + .const 'Sub' $P152 = "29_1275600007.84296" + capture_lex $P152 + .const 'Sub' $P102 = "26_1275600007.84296" + capture_lex $P102 + .const 'Sub' $P84 = "23_1275600007.84296" + capture_lex $P84 + .const 'Sub' $P70 = "21_1275600007.84296" + capture_lex $P70 + .const 'Sub' $P56 = "19_1275600007.84296" + capture_lex $P56 + .const 'Sub' $P48 = "17_1275600007.84296" + capture_lex $P48 + .const 'Sub' $P41 = "15_1275600007.84296" + capture_lex $P41 + .const 'Sub' $P35 = "13_1275600007.84296" + capture_lex $P35 + .const 'Sub' $P15 = "12_1275600007.84296" capture_lex $P15 $P0 = find_dynamic_lex "$*CTXSAVE" if null $P0 goto ctxsave_done @@ -357,76 +363,76 @@ NQP::Compiler - NQP compiler unless $I0 goto ctxsave_done $P0."ctxsave"() ctxsave_done: -.annotate 'line', 550 - get_hll_global $P1295, ["NQP";"Regex"], "_block1294" - capture_lex $P1295 - $P1358 = $P1295() +.annotate 'line', 562 + get_hll_global $P1324, ["NQP";"Regex"], "_block1323" + capture_lex $P1324 + $P1387 = $P1324() .annotate 'line', 4 - .return ($P1358) - .const 'Sub' $P1360 = "353_1275511697.61926" - .return ($P1360) + .return ($P1387) + .const 'Sub' $P1389 = "362_1275600007.84296" + .return ($P1389) .end .namespace ["NQP";"Grammar"] -.sub "" :load :init :subid("post356") :outer("11_1275511697.61926") +.sub "" :load :init :subid("post365") :outer("11_1275600007.84296") .annotate 'line', 4 get_hll_global $P14, ["NQP";"Grammar"], "_block13" .local pmc block set block, $P14 -.annotate 'line', 434 - get_hll_global $P1363, ["NQP"], "Grammar" - $P1363."O"(":prec, :assoc", "%methodop") -.annotate 'line', 435 - get_hll_global $P1364, ["NQP"], "Grammar" - $P1364."O"(":prec, :assoc", "%autoincrement") -.annotate 'line', 436 - get_hll_global $P1365, ["NQP"], "Grammar" - $P1365."O"(":prec, :assoc", "%exponentiation") -.annotate 'line', 437 - get_hll_global $P1366, ["NQP"], "Grammar" - $P1366."O"(":prec, :assoc", "%symbolic_unary") -.annotate 'line', 438 - get_hll_global $P1367, ["NQP"], "Grammar" - $P1367."O"(":prec, :assoc", "%multiplicative") -.annotate 'line', 439 - get_hll_global $P1368, ["NQP"], "Grammar" - $P1368."O"(":prec, :assoc", "%additive") -.annotate 'line', 440 - get_hll_global $P1369, ["NQP"], "Grammar" - $P1369."O"(":prec, :assoc", "%concatenation") -.annotate 'line', 441 - get_hll_global $P1370, ["NQP"], "Grammar" - $P1370."O"(":prec, :assoc", "%relational") -.annotate 'line', 442 - get_hll_global $P1371, ["NQP"], "Grammar" - $P1371."O"(":prec, :assoc", "%tight_and") -.annotate 'line', 443 - get_hll_global $P1372, ["NQP"], "Grammar" - $P1372."O"(":prec, :assoc", "%tight_or") -.annotate 'line', 444 - get_hll_global $P1373, ["NQP"], "Grammar" - $P1373."O"(":prec, :assoc", "%conditional") -.annotate 'line', 445 - get_hll_global $P1374, ["NQP"], "Grammar" - $P1374."O"(":prec, :assoc", "%assignment") .annotate 'line', 446 - get_hll_global $P1375, ["NQP"], "Grammar" - $P1375."O"(":prec, :assoc, :nextterm", "%comma") + get_hll_global $P1392, ["NQP"], "Grammar" + $P1392."O"(":prec, :assoc", "%methodop") .annotate 'line', 447 - get_hll_global $P1376, ["NQP"], "Grammar" - $P1376."O"(":prec, :assoc", "%list_infix") + get_hll_global $P1393, ["NQP"], "Grammar" + $P1393."O"(":prec, :assoc", "%autoincrement") .annotate 'line', 448 - get_hll_global $P1377, ["NQP"], "Grammar" - $P1377."O"(":prec, :assoc", "%list_prefix") -.annotate 'line', 433 - $P1378 = get_root_global ["parrot"], "P6metaclass" - $P1378."new_class"("NQP::Regex", "Regex::P6Regex::Grammar" :named("parent")) + get_hll_global $P1394, ["NQP"], "Grammar" + $P1394."O"(":prec, :assoc", "%exponentiation") +.annotate 'line', 449 + get_hll_global $P1395, ["NQP"], "Grammar" + $P1395."O"(":prec, :assoc", "%symbolic_unary") +.annotate 'line', 450 + get_hll_global $P1396, ["NQP"], "Grammar" + $P1396."O"(":prec, :assoc", "%multiplicative") +.annotate 'line', 451 + get_hll_global $P1397, ["NQP"], "Grammar" + $P1397."O"(":prec, :assoc", "%additive") +.annotate 'line', 452 + get_hll_global $P1398, ["NQP"], "Grammar" + $P1398."O"(":prec, :assoc", "%concatenation") +.annotate 'line', 453 + get_hll_global $P1399, ["NQP"], "Grammar" + $P1399."O"(":prec, :assoc", "%relational") +.annotate 'line', 454 + get_hll_global $P1400, ["NQP"], "Grammar" + $P1400."O"(":prec, :assoc", "%tight_and") +.annotate 'line', 455 + get_hll_global $P1401, ["NQP"], "Grammar" + $P1401."O"(":prec, :assoc", "%tight_or") +.annotate 'line', 456 + get_hll_global $P1402, ["NQP"], "Grammar" + $P1402."O"(":prec, :assoc", "%conditional") +.annotate 'line', 457 + get_hll_global $P1403, ["NQP"], "Grammar" + $P1403."O"(":prec, :assoc", "%assignment") +.annotate 'line', 458 + get_hll_global $P1404, ["NQP"], "Grammar" + $P1404."O"(":prec, :assoc, :nextterm", "%comma") +.annotate 'line', 459 + get_hll_global $P1405, ["NQP"], "Grammar" + $P1405."O"(":prec, :assoc", "%list_infix") +.annotate 'line', 460 + get_hll_global $P1406, ["NQP"], "Grammar" + $P1406."O"(":prec, :assoc", "%list_prefix") +.annotate 'line', 445 + $P1407 = get_root_global ["parrot"], "P6metaclass" + $P1407."new_class"("NQP::Regex", "Regex::P6Regex::Grammar" :named("parent")) .end .namespace ["NQP";"Grammar"] -.sub "TOP" :subid("12_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "TOP" :subid("12_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 new $P17, 'ExceptionHandler' set_addr $P17, control_16 @@ -439,5277 +445,5303 @@ NQP::Compiler - NQP compiler .annotate 'line', 10 new $P19, "Undef" .lex "$*SCOPE", $P19 +.annotate 'line', 11 + new $P20, "Undef" + .lex "$*MULTINESS", $P20 .annotate 'line', 4 - find_lex $P20, "%*LANG" - unless_null $P20, vivify_357 - get_hll_global $P20, "%LANG" - unless_null $P20, vivify_358 + find_lex $P21, "%*LANG" + unless_null $P21, vivify_366 + get_hll_global $P21, "%LANG" + unless_null $P21, vivify_367 die "Contextual %*LANG not found" - vivify_358: - vivify_357: + vivify_367: + vivify_366: .annotate 'line', 6 - get_hll_global $P21, ["NQP"], "Regex" - find_lex $P22, "%*LANG" - unless_null $P22, vivify_359 - get_hll_global $P22, "%LANG" - unless_null $P22, vivify_360 + get_hll_global $P22, ["NQP"], "Regex" + find_lex $P23, "%*LANG" + unless_null $P23, vivify_368 + get_hll_global $P23, "%LANG" + unless_null $P23, vivify_369 die "Contextual %*LANG not found" - vivify_360: - store_lex "%*LANG", $P22 - vivify_359: - set $P22["Regex"], $P21 + vivify_369: + store_lex "%*LANG", $P23 + vivify_368: + set $P23["Regex"], $P22 .annotate 'line', 7 - get_hll_global $P23, ["NQP"], "RegexActions" - find_lex $P24, "%*LANG" - unless_null $P24, vivify_361 - get_hll_global $P24, "%LANG" - unless_null $P24, vivify_362 + get_hll_global $P24, ["NQP"], "RegexActions" + find_lex $P25, "%*LANG" + unless_null $P25, vivify_370 + get_hll_global $P25, "%LANG" + unless_null $P25, vivify_371 die "Contextual %*LANG not found" - vivify_362: - store_lex "%*LANG", $P24 - vivify_361: - set $P24["Regex-actions"], $P23 + vivify_371: + store_lex "%*LANG", $P25 + vivify_370: + set $P25["Regex-actions"], $P24 .annotate 'line', 8 - get_hll_global $P25, ["NQP"], "Grammar" - find_lex $P26, "%*LANG" - unless_null $P26, vivify_363 - get_hll_global $P26, "%LANG" - unless_null $P26, vivify_364 + get_hll_global $P26, ["NQP"], "Grammar" + find_lex $P27, "%*LANG" + unless_null $P27, vivify_372 + get_hll_global $P27, "%LANG" + unless_null $P27, vivify_373 die "Contextual %*LANG not found" - vivify_364: - store_lex "%*LANG", $P26 - vivify_363: - set $P26["MAIN"], $P25 + vivify_373: + store_lex "%*LANG", $P27 + vivify_372: + set $P27["MAIN"], $P26 .annotate 'line', 9 - get_hll_global $P27, ["NQP"], "Actions" - find_lex $P28, "%*LANG" - unless_null $P28, vivify_365 - get_hll_global $P28, "%LANG" - unless_null $P28, vivify_366 + get_hll_global $P28, ["NQP"], "Actions" + find_lex $P29, "%*LANG" + unless_null $P29, vivify_374 + get_hll_global $P29, "%LANG" + unless_null $P29, vivify_375 die "Contextual %*LANG not found" - vivify_366: - store_lex "%*LANG", $P28 - vivify_365: - set $P28["MAIN-actions"], $P27 + vivify_375: + store_lex "%*LANG", $P29 + vivify_374: + set $P29["MAIN-actions"], $P28 .annotate 'line', 10 - new $P29, "String" - assign $P29, "" - store_lex "$*SCOPE", $P29 + new $P30, "String" + assign $P30, "" + store_lex "$*SCOPE", $P30 .annotate 'line', 11 - find_lex $P30, "self" - $P31 = $P30."comp_unit"() -.annotate 'line', 4 - .return ($P31) + new $P31, "String" + assign $P31, "" + store_lex "$*MULTINESS", $P31 +.annotate 'line', 12 + find_lex $P32, "self" + $P33 = $P32."comp_unit"() +.annotate 'line', 4 + .return ($P33) control_16: .local pmc exception .get_results (exception) - getattribute $P32, exception, "payload" - .return ($P32) + getattribute $P34, exception, "payload" + .return ($P34) .end .namespace ["NQP";"Grammar"] -.sub "identifier" :subid("13_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "identifier" :subid("13_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx34_tgt - .local int rx34_pos - .local int rx34_off - .local int rx34_eos - .local int rx34_rep - .local pmc rx34_cur - (rx34_cur, rx34_pos, rx34_tgt) = self."!cursor_start"() - rx34_cur."!cursor_debug"("START ", "identifier") - .lex unicode:"$\x{a2}", rx34_cur + .local string rx36_tgt + .local int rx36_pos + .local int rx36_off + .local int rx36_eos + .local int rx36_rep + .local pmc rx36_cur + (rx36_cur, rx36_pos, rx36_tgt) = self."!cursor_start"() + rx36_cur."!cursor_debug"("START ", "identifier") + .lex unicode:"$\x{a2}", rx36_cur .local pmc match .lex "$/", match - length rx34_eos, rx34_tgt - gt rx34_pos, rx34_eos, rx34_done - set rx34_off, 0 - lt rx34_pos, 2, rx34_start - sub rx34_off, rx34_pos, 1 - substr rx34_tgt, rx34_tgt, rx34_off - rx34_start: + length rx36_eos, rx36_tgt + gt rx36_pos, rx36_eos, rx36_done + set rx36_off, 0 + lt rx36_pos, 2, rx36_start + sub rx36_off, rx36_pos, 1 + substr rx36_tgt, rx36_tgt, rx36_off + rx36_start: $I10 = self.'from'() - ne $I10, -1, rxscan38_done - goto rxscan38_scan - rxscan38_loop: - ($P10) = rx34_cur."from"() + ne $I10, -1, rxscan40_done + goto rxscan40_scan + rxscan40_loop: + ($P10) = rx36_cur."from"() inc $P10 - set rx34_pos, $P10 - ge rx34_pos, rx34_eos, rxscan38_done - rxscan38_scan: - set_addr $I10, rxscan38_loop - rx34_cur."!mark_push"(0, rx34_pos, $I10) - rxscan38_done: -.annotate 'line', 16 + set rx36_pos, $P10 + ge rx36_pos, rx36_eos, rxscan40_done + rxscan40_scan: + set_addr $I10, rxscan40_loop + rx36_cur."!mark_push"(0, rx36_pos, $I10) + rxscan40_done: +.annotate 'line', 17 # rx subrule "ident" subtype=capture negate= - rx34_cur."!cursor_pos"(rx34_pos) - $P10 = rx34_cur."ident"() - unless $P10, rx34_fail - rx34_cur."!mark_push"(0, -1, 0, $P10) + rx36_cur."!cursor_pos"(rx36_pos) + $P10 = rx36_cur."ident"() + unless $P10, rx36_fail + rx36_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("ident") - rx34_pos = $P10."pos"() + rx36_pos = $P10."pos"() # rx pass - rx34_cur."!cursor_pass"(rx34_pos, "identifier") - rx34_cur."!cursor_debug"("PASS ", "identifier", " at pos=", rx34_pos) - .return (rx34_cur) - rx34_fail: -.annotate 'line', 4 - (rx34_rep, rx34_pos, $I10, $P10) = rx34_cur."!mark_fail"(0) - lt rx34_pos, -1, rx34_done - eq rx34_pos, -1, rx34_fail + rx36_cur."!cursor_pass"(rx36_pos, "identifier") + rx36_cur."!cursor_debug"("PASS ", "identifier", " at pos=", rx36_pos) + .return (rx36_cur) + rx36_fail: +.annotate 'line', 4 + (rx36_rep, rx36_pos, $I10, $P10) = rx36_cur."!mark_fail"(0) + lt rx36_pos, -1, rx36_done + eq rx36_pos, -1, rx36_fail jump $I10 - rx34_done: - rx34_cur."!cursor_fail"() - rx34_cur."!cursor_debug"("FAIL ", "identifier") - .return (rx34_cur) + rx36_done: + rx36_cur."!cursor_fail"() + rx36_cur."!cursor_debug"("FAIL ", "identifier") + .return (rx36_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__identifier" :subid("14_1275511697.61926") :method +.sub "!PREFIX__identifier" :subid("14_1275600007.84296") :method .annotate 'line', 4 - $P36 = self."!PREFIX__!subrule"("ident", "") - new $P37, "ResizablePMCArray" - push $P37, $P36 - .return ($P37) + $P38 = self."!PREFIX__!subrule"("ident", "") + new $P39, "ResizablePMCArray" + push $P39, $P38 + .return ($P39) .end .namespace ["NQP";"Grammar"] -.sub "name" :subid("15_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "name" :subid("15_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx40_tgt - .local int rx40_pos - .local int rx40_off - .local int rx40_eos - .local int rx40_rep - .local pmc rx40_cur - (rx40_cur, rx40_pos, rx40_tgt) = self."!cursor_start"() - rx40_cur."!cursor_debug"("START ", "name") - rx40_cur."!cursor_caparray"("identifier") - .lex unicode:"$\x{a2}", rx40_cur + .local string rx42_tgt + .local int rx42_pos + .local int rx42_off + .local int rx42_eos + .local int rx42_rep + .local pmc rx42_cur + (rx42_cur, rx42_pos, rx42_tgt) = self."!cursor_start"() + rx42_cur."!cursor_debug"("START ", "name") + rx42_cur."!cursor_caparray"("identifier") + .lex unicode:"$\x{a2}", rx42_cur .local pmc match .lex "$/", match - length rx40_eos, rx40_tgt - gt rx40_pos, rx40_eos, rx40_done - set rx40_off, 0 - lt rx40_pos, 2, rx40_start - sub rx40_off, rx40_pos, 1 - substr rx40_tgt, rx40_tgt, rx40_off - rx40_start: + length rx42_eos, rx42_tgt + gt rx42_pos, rx42_eos, rx42_done + set rx42_off, 0 + lt rx42_pos, 2, rx42_start + sub rx42_off, rx42_pos, 1 + substr rx42_tgt, rx42_tgt, rx42_off + rx42_start: $I10 = self.'from'() - ne $I10, -1, rxscan43_done - goto rxscan43_scan - rxscan43_loop: - ($P10) = rx40_cur."from"() + ne $I10, -1, rxscan45_done + goto rxscan45_scan + rxscan45_loop: + ($P10) = rx42_cur."from"() inc $P10 - set rx40_pos, $P10 - ge rx40_pos, rx40_eos, rxscan43_done - rxscan43_scan: - set_addr $I10, rxscan43_loop - rx40_cur."!mark_push"(0, rx40_pos, $I10) - rxscan43_done: -.annotate 'line', 18 - # rx rxquantr44 ** 1..* - set_addr $I45, rxquantr44_done - rx40_cur."!mark_push"(0, -1, $I45) - rxquantr44_loop: + set rx42_pos, $P10 + ge rx42_pos, rx42_eos, rxscan45_done + rxscan45_scan: + set_addr $I10, rxscan45_loop + rx42_cur."!mark_push"(0, rx42_pos, $I10) + rxscan45_done: +.annotate 'line', 19 + # rx rxquantr46 ** 1..* + set_addr $I47, rxquantr46_done + rx42_cur."!mark_push"(0, -1, $I47) + rxquantr46_loop: # rx subrule "identifier" subtype=capture negate= - rx40_cur."!cursor_pos"(rx40_pos) - $P10 = rx40_cur."identifier"() - unless $P10, rx40_fail - rx40_cur."!mark_push"(0, -1, 0, $P10) + rx42_cur."!cursor_pos"(rx42_pos) + $P10 = rx42_cur."identifier"() + unless $P10, rx42_fail + rx42_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("identifier") - rx40_pos = $P10."pos"() - (rx40_rep) = rx40_cur."!mark_commit"($I45) - rx40_cur."!mark_push"(rx40_rep, rx40_pos, $I45) + rx42_pos = $P10."pos"() + (rx42_rep) = rx42_cur."!mark_commit"($I47) + rx42_cur."!mark_push"(rx42_rep, rx42_pos, $I47) # rx literal "::" - add $I11, rx40_pos, 2 - gt $I11, rx40_eos, rx40_fail - sub $I11, rx40_pos, rx40_off - substr $S10, rx40_tgt, $I11, 2 - ne $S10, "::", rx40_fail - add rx40_pos, 2 - goto rxquantr44_loop - rxquantr44_done: + add $I11, rx42_pos, 2 + gt $I11, rx42_eos, rx42_fail + sub $I11, rx42_pos, rx42_off + substr $S10, rx42_tgt, $I11, 2 + ne $S10, "::", rx42_fail + add rx42_pos, 2 + goto rxquantr46_loop + rxquantr46_done: # rx pass - rx40_cur."!cursor_pass"(rx40_pos, "name") - rx40_cur."!cursor_debug"("PASS ", "name", " at pos=", rx40_pos) - .return (rx40_cur) - rx40_fail: -.annotate 'line', 4 - (rx40_rep, rx40_pos, $I10, $P10) = rx40_cur."!mark_fail"(0) - lt rx40_pos, -1, rx40_done - eq rx40_pos, -1, rx40_fail + rx42_cur."!cursor_pass"(rx42_pos, "name") + rx42_cur."!cursor_debug"("PASS ", "name", " at pos=", rx42_pos) + .return (rx42_cur) + rx42_fail: +.annotate 'line', 4 + (rx42_rep, rx42_pos, $I10, $P10) = rx42_cur."!mark_fail"(0) + lt rx42_pos, -1, rx42_done + eq rx42_pos, -1, rx42_fail jump $I10 - rx40_done: - rx40_cur."!cursor_fail"() - rx40_cur."!cursor_debug"("FAIL ", "name") - .return (rx40_cur) + rx42_done: + rx42_cur."!cursor_fail"() + rx42_cur."!cursor_debug"("FAIL ", "name") + .return (rx42_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__name" :subid("16_1275511697.61926") :method +.sub "!PREFIX__name" :subid("16_1275600007.84296") :method .annotate 'line', 4 - new $P42, "ResizablePMCArray" - push $P42, "" - .return ($P42) + new $P44, "ResizablePMCArray" + push $P44, "" + .return ($P44) .end .namespace ["NQP";"Grammar"] -.sub "deflongname" :subid("17_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "deflongname" :subid("17_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx47_tgt - .local int rx47_pos - .local int rx47_off - .local int rx47_eos - .local int rx47_rep - .local pmc rx47_cur - (rx47_cur, rx47_pos, rx47_tgt) = self."!cursor_start"() - rx47_cur."!cursor_debug"("START ", "deflongname") - rx47_cur."!cursor_caparray"("colonpair") - .lex unicode:"$\x{a2}", rx47_cur + .local string rx49_tgt + .local int rx49_pos + .local int rx49_off + .local int rx49_eos + .local int rx49_rep + .local pmc rx49_cur + (rx49_cur, rx49_pos, rx49_tgt) = self."!cursor_start"() + rx49_cur."!cursor_debug"("START ", "deflongname") + rx49_cur."!cursor_caparray"("colonpair") + .lex unicode:"$\x{a2}", rx49_cur .local pmc match .lex "$/", match - length rx47_eos, rx47_tgt - gt rx47_pos, rx47_eos, rx47_done - set rx47_off, 0 - lt rx47_pos, 2, rx47_start - sub rx47_off, rx47_pos, 1 - substr rx47_tgt, rx47_tgt, rx47_off - rx47_start: + length rx49_eos, rx49_tgt + gt rx49_pos, rx49_eos, rx49_done + set rx49_off, 0 + lt rx49_pos, 2, rx49_start + sub rx49_off, rx49_pos, 1 + substr rx49_tgt, rx49_tgt, rx49_off + rx49_start: $I10 = self.'from'() - ne $I10, -1, rxscan51_done - goto rxscan51_scan - rxscan51_loop: - ($P10) = rx47_cur."from"() + ne $I10, -1, rxscan53_done + goto rxscan53_scan + rxscan53_loop: + ($P10) = rx49_cur."from"() inc $P10 - set rx47_pos, $P10 - ge rx47_pos, rx47_eos, rxscan51_done - rxscan51_scan: - set_addr $I10, rxscan51_loop - rx47_cur."!mark_push"(0, rx47_pos, $I10) - rxscan51_done: -.annotate 'line', 21 + set rx49_pos, $P10 + ge rx49_pos, rx49_eos, rxscan53_done + rxscan53_scan: + set_addr $I10, rxscan53_loop + rx49_cur."!mark_push"(0, rx49_pos, $I10) + rxscan53_done: +.annotate 'line', 22 # rx subrule "identifier" subtype=capture negate= - rx47_cur."!cursor_pos"(rx47_pos) - $P10 = rx47_cur."identifier"() - unless $P10, rx47_fail - rx47_cur."!mark_push"(0, -1, 0, $P10) + rx49_cur."!cursor_pos"(rx49_pos) + $P10 = rx49_cur."identifier"() + unless $P10, rx49_fail + rx49_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("identifier") - rx47_pos = $P10."pos"() - # rx rxquantr52 ** 0..1 - set_addr $I53, rxquantr52_done - rx47_cur."!mark_push"(0, rx47_pos, $I53) - rxquantr52_loop: + rx49_pos = $P10."pos"() + # rx rxquantr54 ** 0..1 + set_addr $I55, rxquantr54_done + rx49_cur."!mark_push"(0, rx49_pos, $I55) + rxquantr54_loop: # rx subrule "colonpair" subtype=capture negate= - rx47_cur."!cursor_pos"(rx47_pos) - $P10 = rx47_cur."colonpair"() - unless $P10, rx47_fail - rx47_cur."!mark_push"(0, -1, 0, $P10) + rx49_cur."!cursor_pos"(rx49_pos) + $P10 = rx49_cur."colonpair"() + unless $P10, rx49_fail + rx49_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("colonpair") - rx47_pos = $P10."pos"() - (rx47_rep) = rx47_cur."!mark_commit"($I53) - rxquantr52_done: -.annotate 'line', 20 + rx49_pos = $P10."pos"() + (rx49_rep) = rx49_cur."!mark_commit"($I55) + rxquantr54_done: +.annotate 'line', 21 # rx pass - rx47_cur."!cursor_pass"(rx47_pos, "deflongname") - rx47_cur."!cursor_debug"("PASS ", "deflongname", " at pos=", rx47_pos) - .return (rx47_cur) - rx47_fail: -.annotate 'line', 4 - (rx47_rep, rx47_pos, $I10, $P10) = rx47_cur."!mark_fail"(0) - lt rx47_pos, -1, rx47_done - eq rx47_pos, -1, rx47_fail + rx49_cur."!cursor_pass"(rx49_pos, "deflongname") + rx49_cur."!cursor_debug"("PASS ", "deflongname", " at pos=", rx49_pos) + .return (rx49_cur) + rx49_fail: +.annotate 'line', 4 + (rx49_rep, rx49_pos, $I10, $P10) = rx49_cur."!mark_fail"(0) + lt rx49_pos, -1, rx49_done + eq rx49_pos, -1, rx49_fail jump $I10 - rx47_done: - rx47_cur."!cursor_fail"() - rx47_cur."!cursor_debug"("FAIL ", "deflongname") - .return (rx47_cur) + rx49_done: + rx49_cur."!cursor_fail"() + rx49_cur."!cursor_debug"("FAIL ", "deflongname") + .return (rx49_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__deflongname" :subid("18_1275511697.61926") :method +.sub "!PREFIX__deflongname" :subid("18_1275600007.84296") :method .annotate 'line', 4 - $P49 = self."!PREFIX__!subrule"("identifier", "") - new $P50, "ResizablePMCArray" - push $P50, $P49 - .return ($P50) + $P51 = self."!PREFIX__!subrule"("identifier", "") + new $P52, "ResizablePMCArray" + push $P52, $P51 + .return ($P52) .end .namespace ["NQP";"Grammar"] -.sub "ENDSTMT" :subid("19_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "ENDSTMT" :subid("19_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx55_tgt - .local int rx55_pos - .local int rx55_off - .local int rx55_eos - .local int rx55_rep - .local pmc rx55_cur - (rx55_cur, rx55_pos, rx55_tgt) = self."!cursor_start"() - rx55_cur."!cursor_debug"("START ", "ENDSTMT") - .lex unicode:"$\x{a2}", rx55_cur + .local string rx57_tgt + .local int rx57_pos + .local int rx57_off + .local int rx57_eos + .local int rx57_rep + .local pmc rx57_cur + (rx57_cur, rx57_pos, rx57_tgt) = self."!cursor_start"() + rx57_cur."!cursor_debug"("START ", "ENDSTMT") + .lex unicode:"$\x{a2}", rx57_cur .local pmc match .lex "$/", match - length rx55_eos, rx55_tgt - gt rx55_pos, rx55_eos, rx55_done - set rx55_off, 0 - lt rx55_pos, 2, rx55_start - sub rx55_off, rx55_pos, 1 - substr rx55_tgt, rx55_tgt, rx55_off - rx55_start: + length rx57_eos, rx57_tgt + gt rx57_pos, rx57_eos, rx57_done + set rx57_off, 0 + lt rx57_pos, 2, rx57_start + sub rx57_off, rx57_pos, 1 + substr rx57_tgt, rx57_tgt, rx57_off + rx57_start: $I10 = self.'from'() - ne $I10, -1, rxscan58_done - goto rxscan58_scan - rxscan58_loop: - ($P10) = rx55_cur."from"() + ne $I10, -1, rxscan60_done + goto rxscan60_scan + rxscan60_loop: + ($P10) = rx57_cur."from"() inc $P10 - set rx55_pos, $P10 - ge rx55_pos, rx55_eos, rxscan58_done - rxscan58_scan: - set_addr $I10, rxscan58_loop - rx55_cur."!mark_push"(0, rx55_pos, $I10) - rxscan58_done: -.annotate 'line', 28 - # rx rxquantr59 ** 0..1 - set_addr $I67, rxquantr59_done - rx55_cur."!mark_push"(0, rx55_pos, $I67) - rxquantr59_loop: - alt60_0: -.annotate 'line', 25 - set_addr $I10, alt60_1 - rx55_cur."!mark_push"(0, rx55_pos, $I10) -.annotate 'line', 26 - # rx rxquantr61 ** 0..* - set_addr $I62, rxquantr61_done - rx55_cur."!mark_push"(0, rx55_pos, $I62) + set rx57_pos, $P10 + ge rx57_pos, rx57_eos, rxscan60_done + rxscan60_scan: + set_addr $I10, rxscan60_loop + rx57_cur."!mark_push"(0, rx57_pos, $I10) + rxscan60_done: +.annotate 'line', 29 + # rx rxquantr61 ** 0..1 + set_addr $I69, rxquantr61_done + rx57_cur."!mark_push"(0, rx57_pos, $I69) rxquantr61_loop: + alt62_0: +.annotate 'line', 26 + set_addr $I10, alt62_1 + rx57_cur."!mark_push"(0, rx57_pos, $I10) +.annotate 'line', 27 + # rx rxquantr63 ** 0..* + set_addr $I64, rxquantr63_done + rx57_cur."!mark_push"(0, rx57_pos, $I64) + rxquantr63_loop: # rx enumcharlist negate=0 - ge rx55_pos, rx55_eos, rx55_fail - sub $I10, rx55_pos, rx55_off - substr $S10, rx55_tgt, $I10, 1 + ge rx57_pos, rx57_eos, rx57_fail + sub $I10, rx57_pos, rx57_off + substr $S10, rx57_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx55_fail - inc rx55_pos - (rx55_rep) = rx55_cur."!mark_commit"($I62) - rx55_cur."!mark_push"(rx55_rep, rx55_pos, $I62) - goto rxquantr61_loop - rxquantr61_done: + lt $I11, 0, rx57_fail + inc rx57_pos + (rx57_rep) = rx57_cur."!mark_commit"($I64) + rx57_cur."!mark_push"(rx57_rep, rx57_pos, $I64) + goto rxquantr63_loop + rxquantr63_done: # rxanchor eol - sub $I10, rx55_pos, rx55_off - is_cclass $I11, 4096, rx55_tgt, $I10 - if $I11, rxanchor63_done - ne rx55_pos, rx55_eos, rx55_fail - eq rx55_pos, 0, rxanchor63_done + sub $I10, rx57_pos, rx57_off + is_cclass $I11, 4096, rx57_tgt, $I10 + if $I11, rxanchor65_done + ne rx57_pos, rx57_eos, rx57_fail + eq rx57_pos, 0, rxanchor65_done dec $I10 - is_cclass $I11, 4096, rx55_tgt, $I10 - if $I11, rx55_fail - rxanchor63_done: + is_cclass $I11, 4096, rx57_tgt, $I10 + if $I11, rx57_fail + rxanchor65_done: # rx subrule "ws" subtype=method negate= - rx55_cur."!cursor_pos"(rx55_pos) - $P10 = rx55_cur."ws"() - unless $P10, rx55_fail - rx55_pos = $P10."pos"() + rx57_cur."!cursor_pos"(rx57_pos) + $P10 = rx57_cur."ws"() + unless $P10, rx57_fail + rx57_pos = $P10."pos"() # rx subrule "MARKER" subtype=zerowidth negate= - rx55_cur."!cursor_pos"(rx55_pos) - $P10 = rx55_cur."MARKER"("endstmt") - unless $P10, rx55_fail - goto alt60_end - alt60_1: -.annotate 'line', 27 - # rx rxquantr64 ** 0..1 - set_addr $I65, rxquantr64_done - rx55_cur."!mark_push"(0, rx55_pos, $I65) - rxquantr64_loop: + rx57_cur."!cursor_pos"(rx57_pos) + $P10 = rx57_cur."MARKER"("endstmt") + unless $P10, rx57_fail + goto alt62_end + alt62_1: +.annotate 'line', 28 + # rx rxquantr66 ** 0..1 + set_addr $I67, rxquantr66_done + rx57_cur."!mark_push"(0, rx57_pos, $I67) + rxquantr66_loop: # rx subrule "unv" subtype=method negate= - rx55_cur."!cursor_pos"(rx55_pos) - $P10 = rx55_cur."unv"() - unless $P10, rx55_fail - rx55_pos = $P10."pos"() - (rx55_rep) = rx55_cur."!mark_commit"($I65) - rxquantr64_done: + rx57_cur."!cursor_pos"(rx57_pos) + $P10 = rx57_cur."unv"() + unless $P10, rx57_fail + rx57_pos = $P10."pos"() + (rx57_rep) = rx57_cur."!mark_commit"($I67) + rxquantr66_done: # rxanchor eol - sub $I10, rx55_pos, rx55_off - is_cclass $I11, 4096, rx55_tgt, $I10 - if $I11, rxanchor66_done - ne rx55_pos, rx55_eos, rx55_fail - eq rx55_pos, 0, rxanchor66_done + sub $I10, rx57_pos, rx57_off + is_cclass $I11, 4096, rx57_tgt, $I10 + if $I11, rxanchor68_done + ne rx57_pos, rx57_eos, rx57_fail + eq rx57_pos, 0, rxanchor68_done dec $I10 - is_cclass $I11, 4096, rx55_tgt, $I10 - if $I11, rx55_fail - rxanchor66_done: + is_cclass $I11, 4096, rx57_tgt, $I10 + if $I11, rx57_fail + rxanchor68_done: # rx subrule "ws" subtype=method negate= - rx55_cur."!cursor_pos"(rx55_pos) - $P10 = rx55_cur."ws"() - unless $P10, rx55_fail - rx55_pos = $P10."pos"() + rx57_cur."!cursor_pos"(rx57_pos) + $P10 = rx57_cur."ws"() + unless $P10, rx57_fail + rx57_pos = $P10."pos"() # rx subrule "MARKER" subtype=zerowidth negate= - rx55_cur."!cursor_pos"(rx55_pos) - $P10 = rx55_cur."MARKER"("endstmt") - unless $P10, rx55_fail - alt60_end: -.annotate 'line', 28 - (rx55_rep) = rx55_cur."!mark_commit"($I67) - rxquantr59_done: -.annotate 'line', 24 + rx57_cur."!cursor_pos"(rx57_pos) + $P10 = rx57_cur."MARKER"("endstmt") + unless $P10, rx57_fail + alt62_end: +.annotate 'line', 29 + (rx57_rep) = rx57_cur."!mark_commit"($I69) + rxquantr61_done: +.annotate 'line', 25 # rx pass - rx55_cur."!cursor_pass"(rx55_pos, "ENDSTMT") - rx55_cur."!cursor_debug"("PASS ", "ENDSTMT", " at pos=", rx55_pos) - .return (rx55_cur) - rx55_fail: -.annotate 'line', 4 - (rx55_rep, rx55_pos, $I10, $P10) = rx55_cur."!mark_fail"(0) - lt rx55_pos, -1, rx55_done - eq rx55_pos, -1, rx55_fail + rx57_cur."!cursor_pass"(rx57_pos, "ENDSTMT") + rx57_cur."!cursor_debug"("PASS ", "ENDSTMT", " at pos=", rx57_pos) + .return (rx57_cur) + rx57_fail: +.annotate 'line', 4 + (rx57_rep, rx57_pos, $I10, $P10) = rx57_cur."!mark_fail"(0) + lt rx57_pos, -1, rx57_done + eq rx57_pos, -1, rx57_fail jump $I10 - rx55_done: - rx55_cur."!cursor_fail"() - rx55_cur."!cursor_debug"("FAIL ", "ENDSTMT") - .return (rx55_cur) + rx57_done: + rx57_cur."!cursor_fail"() + rx57_cur."!cursor_debug"("FAIL ", "ENDSTMT") + .return (rx57_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__ENDSTMT" :subid("20_1275511697.61926") :method +.sub "!PREFIX__ENDSTMT" :subid("20_1275600007.84296") :method .annotate 'line', 4 - new $P57, "ResizablePMCArray" - push $P57, "" - .return ($P57) + new $P59, "ResizablePMCArray" + push $P59, "" + .return ($P59) .end .namespace ["NQP";"Grammar"] -.sub "ws" :subid("21_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "ws" :subid("21_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx69_tgt - .local int rx69_pos - .local int rx69_off - .local int rx69_eos - .local int rx69_rep - .local pmc rx69_cur - (rx69_cur, rx69_pos, rx69_tgt) = self."!cursor_start"() - rx69_cur."!cursor_debug"("START ", "ws") - .lex unicode:"$\x{a2}", rx69_cur + .local string rx71_tgt + .local int rx71_pos + .local int rx71_off + .local int rx71_eos + .local int rx71_rep + .local pmc rx71_cur + (rx71_cur, rx71_pos, rx71_tgt) = self."!cursor_start"() + rx71_cur."!cursor_debug"("START ", "ws") + .lex unicode:"$\x{a2}", rx71_cur .local pmc match .lex "$/", match - length rx69_eos, rx69_tgt - gt rx69_pos, rx69_eos, rx69_done - set rx69_off, 0 - lt rx69_pos, 2, rx69_start - sub rx69_off, rx69_pos, 1 - substr rx69_tgt, rx69_tgt, rx69_off - rx69_start: + length rx71_eos, rx71_tgt + gt rx71_pos, rx71_eos, rx71_done + set rx71_off, 0 + lt rx71_pos, 2, rx71_start + sub rx71_off, rx71_pos, 1 + substr rx71_tgt, rx71_tgt, rx71_off + rx71_start: $I10 = self.'from'() - ne $I10, -1, rxscan72_done - goto rxscan72_scan - rxscan72_loop: - ($P10) = rx69_cur."from"() + ne $I10, -1, rxscan74_done + goto rxscan74_scan + rxscan74_loop: + ($P10) = rx71_cur."from"() inc $P10 - set rx69_pos, $P10 - ge rx69_pos, rx69_eos, rxscan72_done - rxscan72_scan: - set_addr $I10, rxscan72_loop - rx69_cur."!mark_push"(0, rx69_pos, $I10) - rxscan72_done: - alt73_0: -.annotate 'line', 31 - set_addr $I10, alt73_1 - rx69_cur."!mark_push"(0, rx69_pos, $I10) + set rx71_pos, $P10 + ge rx71_pos, rx71_eos, rxscan74_done + rxscan74_scan: + set_addr $I10, rxscan74_loop + rx71_cur."!mark_push"(0, rx71_pos, $I10) + rxscan74_done: + alt75_0: .annotate 'line', 32 - # rx subrule "MARKED" subtype=zerowidth negate= - rx69_cur."!cursor_pos"(rx69_pos) - $P10 = rx69_cur."MARKED"("ws") - unless $P10, rx69_fail - goto alt73_end - alt73_1: + set_addr $I10, alt75_1 + rx71_cur."!mark_push"(0, rx71_pos, $I10) .annotate 'line', 33 - # rx subrule "ww" subtype=zerowidth negate=1 - rx69_cur."!cursor_pos"(rx69_pos) - $P10 = rx69_cur."ww"() - if $P10, rx69_fail -.annotate 'line', 38 - # rx rxquantr74 ** 0..* - set_addr $I81, rxquantr74_done - rx69_cur."!mark_push"(0, rx69_pos, $I81) - rxquantr74_loop: - alt75_0: + # rx subrule "MARKED" subtype=zerowidth negate= + rx71_cur."!cursor_pos"(rx71_pos) + $P10 = rx71_cur."MARKED"("ws") + unless $P10, rx71_fail + goto alt75_end + alt75_1: .annotate 'line', 34 - set_addr $I10, alt75_1 - rx69_cur."!mark_push"(0, rx69_pos, $I10) - # rx rxquantr76 ** 1..* - set_addr $I77, rxquantr76_done - rx69_cur."!mark_push"(0, -1, $I77) + # rx subrule "ww" subtype=zerowidth negate=1 + rx71_cur."!cursor_pos"(rx71_pos) + $P10 = rx71_cur."ww"() + if $P10, rx71_fail +.annotate 'line', 39 + # rx rxquantr76 ** 0..* + set_addr $I83, rxquantr76_done + rx71_cur."!mark_push"(0, rx71_pos, $I83) rxquantr76_loop: + alt77_0: +.annotate 'line', 35 + set_addr $I10, alt77_1 + rx71_cur."!mark_push"(0, rx71_pos, $I10) + # rx rxquantr78 ** 1..* + set_addr $I79, rxquantr78_done + rx71_cur."!mark_push"(0, -1, $I79) + rxquantr78_loop: # rx enumcharlist negate=0 - ge rx69_pos, rx69_eos, rx69_fail - sub $I10, rx69_pos, rx69_off - substr $S10, rx69_tgt, $I10, 1 + ge rx71_pos, rx71_eos, rx71_fail + sub $I10, rx71_pos, rx71_off + substr $S10, rx71_tgt, $I10, 1 index $I11, unicode:"\n\x{b}\f\r\x{85}\u2028\u2029", $S10 - lt $I11, 0, rx69_fail - inc rx69_pos - (rx69_rep) = rx69_cur."!mark_commit"($I77) - rx69_cur."!mark_push"(rx69_rep, rx69_pos, $I77) - goto rxquantr76_loop - rxquantr76_done: - goto alt75_end - alt75_1: - set_addr $I10, alt75_2 - rx69_cur."!mark_push"(0, rx69_pos, $I10) -.annotate 'line', 35 + lt $I11, 0, rx71_fail + inc rx71_pos + (rx71_rep) = rx71_cur."!mark_commit"($I79) + rx71_cur."!mark_push"(rx71_rep, rx71_pos, $I79) + goto rxquantr78_loop + rxquantr78_done: + goto alt77_end + alt77_1: + set_addr $I10, alt77_2 + rx71_cur."!mark_push"(0, rx71_pos, $I10) +.annotate 'line', 36 # rx literal "#" - add $I11, rx69_pos, 1 - gt $I11, rx69_eos, rx69_fail - sub $I11, rx69_pos, rx69_off - substr $S10, rx69_tgt, $I11, 1 - ne $S10, "#", rx69_fail - add rx69_pos, 1 + add $I11, rx71_pos, 1 + gt $I11, rx71_eos, rx71_fail + sub $I11, rx71_pos, rx71_off + substr $S10, rx71_tgt, $I11, 1 + ne $S10, "#", rx71_fail + add rx71_pos, 1 # rx charclass_q N r 0..-1 - sub $I10, rx69_pos, rx69_off - find_cclass $I11, 4096, rx69_tgt, $I10, rx69_eos - add rx69_pos, rx69_off, $I11 - goto alt75_end - alt75_2: - set_addr $I10, alt75_3 - rx69_cur."!mark_push"(0, rx69_pos, $I10) -.annotate 'line', 36 + sub $I10, rx71_pos, rx71_off + find_cclass $I11, 4096, rx71_tgt, $I10, rx71_eos + add rx71_pos, rx71_off, $I11 + goto alt77_end + alt77_2: + set_addr $I10, alt77_3 + rx71_cur."!mark_push"(0, rx71_pos, $I10) +.annotate 'line', 37 # rxanchor bol - eq rx69_pos, 0, rxanchor78_done - ge rx69_pos, rx69_eos, rx69_fail - sub $I10, rx69_pos, rx69_off + eq rx71_pos, 0, rxanchor80_done + ge rx71_pos, rx71_eos, rx71_fail + sub $I10, rx71_pos, rx71_off dec $I10 - is_cclass $I11, 4096, rx69_tgt, $I10 - unless $I11, rx69_fail - rxanchor78_done: + is_cclass $I11, 4096, rx71_tgt, $I10 + unless $I11, rx71_fail + rxanchor80_done: # rx subrule "pod_comment" subtype=method negate= - rx69_cur."!cursor_pos"(rx69_pos) - $P10 = rx69_cur."pod_comment"() - unless $P10, rx69_fail - rx69_pos = $P10."pos"() - goto alt75_end - alt75_3: -.annotate 'line', 37 - # rx rxquantr79 ** 1..* - set_addr $I80, rxquantr79_done - rx69_cur."!mark_push"(0, -1, $I80) - rxquantr79_loop: + rx71_cur."!cursor_pos"(rx71_pos) + $P10 = rx71_cur."pod_comment"() + unless $P10, rx71_fail + rx71_pos = $P10."pos"() + goto alt77_end + alt77_3: +.annotate 'line', 38 + # rx rxquantr81 ** 1..* + set_addr $I82, rxquantr81_done + rx71_cur."!mark_push"(0, -1, $I82) + rxquantr81_loop: # rx enumcharlist negate=0 - ge rx69_pos, rx69_eos, rx69_fail - sub $I10, rx69_pos, rx69_off - substr $S10, rx69_tgt, $I10, 1 + ge rx71_pos, rx71_eos, rx71_fail + sub $I10, rx71_pos, rx71_off + substr $S10, rx71_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx69_fail - inc rx69_pos - (rx69_rep) = rx69_cur."!mark_commit"($I80) - rx69_cur."!mark_push"(rx69_rep, rx69_pos, $I80) - goto rxquantr79_loop - rxquantr79_done: - alt75_end: -.annotate 'line', 38 - (rx69_rep) = rx69_cur."!mark_commit"($I81) - rx69_cur."!mark_push"(rx69_rep, rx69_pos, $I81) - goto rxquantr74_loop - rxquantr74_done: + lt $I11, 0, rx71_fail + inc rx71_pos + (rx71_rep) = rx71_cur."!mark_commit"($I82) + rx71_cur."!mark_push"(rx71_rep, rx71_pos, $I82) + goto rxquantr81_loop + rxquantr81_done: + alt77_end: .annotate 'line', 39 + (rx71_rep) = rx71_cur."!mark_commit"($I83) + rx71_cur."!mark_push"(rx71_rep, rx71_pos, $I83) + goto rxquantr76_loop + rxquantr76_done: +.annotate 'line', 40 # rx subrule "MARKER" subtype=zerowidth negate= - rx69_cur."!cursor_pos"(rx69_pos) - $P10 = rx69_cur."MARKER"("ws") - unless $P10, rx69_fail - alt73_end: -.annotate 'line', 31 + rx71_cur."!cursor_pos"(rx71_pos) + $P10 = rx71_cur."MARKER"("ws") + unless $P10, rx71_fail + alt75_end: +.annotate 'line', 32 # rx pass - rx69_cur."!cursor_pass"(rx69_pos, "ws") - rx69_cur."!cursor_debug"("PASS ", "ws", " at pos=", rx69_pos) - .return (rx69_cur) - rx69_fail: -.annotate 'line', 4 - (rx69_rep, rx69_pos, $I10, $P10) = rx69_cur."!mark_fail"(0) - lt rx69_pos, -1, rx69_done - eq rx69_pos, -1, rx69_fail + rx71_cur."!cursor_pass"(rx71_pos, "ws") + rx71_cur."!cursor_debug"("PASS ", "ws", " at pos=", rx71_pos) + .return (rx71_cur) + rx71_fail: +.annotate 'line', 4 + (rx71_rep, rx71_pos, $I10, $P10) = rx71_cur."!mark_fail"(0) + lt rx71_pos, -1, rx71_done + eq rx71_pos, -1, rx71_fail jump $I10 - rx69_done: - rx69_cur."!cursor_fail"() - rx69_cur."!cursor_debug"("FAIL ", "ws") - .return (rx69_cur) + rx71_done: + rx71_cur."!cursor_fail"() + rx71_cur."!cursor_debug"("FAIL ", "ws") + .return (rx71_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__ws" :subid("22_1275511697.61926") :method +.sub "!PREFIX__ws" :subid("22_1275600007.84296") :method .annotate 'line', 4 - new $P71, "ResizablePMCArray" - push $P71, "" - push $P71, "" - .return ($P71) + new $P73, "ResizablePMCArray" + push $P73, "" + push $P73, "" + .return ($P73) .end .namespace ["NQP";"Grammar"] -.sub "unv" :subid("23_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "unv" :subid("23_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .const 'Sub' $P90 = "25_1275511697.61926" - capture_lex $P90 - .local string rx83_tgt - .local int rx83_pos - .local int rx83_off - .local int rx83_eos - .local int rx83_rep - .local pmc rx83_cur - (rx83_cur, rx83_pos, rx83_tgt) = self."!cursor_start"() - rx83_cur."!cursor_debug"("START ", "unv") - .lex unicode:"$\x{a2}", rx83_cur + .const 'Sub' $P92 = "25_1275600007.84296" + capture_lex $P92 + .local string rx85_tgt + .local int rx85_pos + .local int rx85_off + .local int rx85_eos + .local int rx85_rep + .local pmc rx85_cur + (rx85_cur, rx85_pos, rx85_tgt) = self."!cursor_start"() + rx85_cur."!cursor_debug"("START ", "unv") + .lex unicode:"$\x{a2}", rx85_cur .local pmc match .lex "$/", match - length rx83_eos, rx83_tgt - gt rx83_pos, rx83_eos, rx83_done - set rx83_off, 0 - lt rx83_pos, 2, rx83_start - sub rx83_off, rx83_pos, 1 - substr rx83_tgt, rx83_tgt, rx83_off - rx83_start: + length rx85_eos, rx85_tgt + gt rx85_pos, rx85_eos, rx85_done + set rx85_off, 0 + lt rx85_pos, 2, rx85_start + sub rx85_off, rx85_pos, 1 + substr rx85_tgt, rx85_tgt, rx85_off + rx85_start: $I10 = self.'from'() - ne $I10, -1, rxscan86_done - goto rxscan86_scan - rxscan86_loop: - ($P10) = rx83_cur."from"() + ne $I10, -1, rxscan88_done + goto rxscan88_scan + rxscan88_loop: + ($P10) = rx85_cur."from"() inc $P10 - set rx83_pos, $P10 - ge rx83_pos, rx83_eos, rxscan86_done - rxscan86_scan: - set_addr $I10, rxscan86_loop - rx83_cur."!mark_push"(0, rx83_pos, $I10) - rxscan86_done: - alt87_0: -.annotate 'line', 44 - set_addr $I10, alt87_1 - rx83_cur."!mark_push"(0, rx83_pos, $I10) + set rx85_pos, $P10 + ge rx85_pos, rx85_eos, rxscan88_done + rxscan88_scan: + set_addr $I10, rxscan88_loop + rx85_cur."!mark_push"(0, rx85_pos, $I10) + rxscan88_done: + alt89_0: .annotate 'line', 45 + set_addr $I10, alt89_1 + rx85_cur."!mark_push"(0, rx85_pos, $I10) +.annotate 'line', 46 # rxanchor bol - eq rx83_pos, 0, rxanchor88_done - ge rx83_pos, rx83_eos, rx83_fail - sub $I10, rx83_pos, rx83_off + eq rx85_pos, 0, rxanchor90_done + ge rx85_pos, rx85_eos, rx85_fail + sub $I10, rx85_pos, rx85_off dec $I10 - is_cclass $I11, 4096, rx83_tgt, $I10 - unless $I11, rx83_fail - rxanchor88_done: + is_cclass $I11, 4096, rx85_tgt, $I10 + unless $I11, rx85_fail + rxanchor90_done: # rx subrule "before" subtype=zerowidth negate= - rx83_cur."!cursor_pos"(rx83_pos) - .const 'Sub' $P90 = "25_1275511697.61926" - capture_lex $P90 - $P10 = rx83_cur."before"($P90) - unless $P10, rx83_fail + rx85_cur."!cursor_pos"(rx85_pos) + .const 'Sub' $P92 = "25_1275600007.84296" + capture_lex $P92 + $P10 = rx85_cur."before"($P92) + unless $P10, rx85_fail # rx subrule "pod_comment" subtype=method negate= - rx83_cur."!cursor_pos"(rx83_pos) - $P10 = rx83_cur."pod_comment"() - unless $P10, rx83_fail - rx83_pos = $P10."pos"() - goto alt87_end - alt87_1: - set_addr $I10, alt87_2 - rx83_cur."!mark_push"(0, rx83_pos, $I10) -.annotate 'line', 46 - # rx rxquantr96 ** 0..* - set_addr $I97, rxquantr96_done - rx83_cur."!mark_push"(0, rx83_pos, $I97) - rxquantr96_loop: - # rx enumcharlist negate=0 - ge rx83_pos, rx83_eos, rx83_fail - sub $I10, rx83_pos, rx83_off - substr $S10, rx83_tgt, $I10, 1 - index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx83_fail - inc rx83_pos - (rx83_rep) = rx83_cur."!mark_commit"($I97) - rx83_cur."!mark_push"(rx83_rep, rx83_pos, $I97) - goto rxquantr96_loop - rxquantr96_done: - # rx literal "#" - add $I11, rx83_pos, 1 - gt $I11, rx83_eos, rx83_fail - sub $I11, rx83_pos, rx83_off - substr $S10, rx83_tgt, $I11, 1 - ne $S10, "#", rx83_fail - add rx83_pos, 1 - # rx charclass_q N r 0..-1 - sub $I10, rx83_pos, rx83_off - find_cclass $I11, 4096, rx83_tgt, $I10, rx83_eos - add rx83_pos, rx83_off, $I11 - goto alt87_end - alt87_2: + rx85_cur."!cursor_pos"(rx85_pos) + $P10 = rx85_cur."pod_comment"() + unless $P10, rx85_fail + rx85_pos = $P10."pos"() + goto alt89_end + alt89_1: + set_addr $I10, alt89_2 + rx85_cur."!mark_push"(0, rx85_pos, $I10) .annotate 'line', 47 - # rx rxquantr98 ** 1..* + # rx rxquantr98 ** 0..* set_addr $I99, rxquantr98_done - rx83_cur."!mark_push"(0, -1, $I99) + rx85_cur."!mark_push"(0, rx85_pos, $I99) rxquantr98_loop: # rx enumcharlist negate=0 - ge rx83_pos, rx83_eos, rx83_fail - sub $I10, rx83_pos, rx83_off - substr $S10, rx83_tgt, $I10, 1 + ge rx85_pos, rx85_eos, rx85_fail + sub $I10, rx85_pos, rx85_off + substr $S10, rx85_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx83_fail - inc rx83_pos - (rx83_rep) = rx83_cur."!mark_commit"($I99) - rx83_cur."!mark_push"(rx83_rep, rx83_pos, $I99) + lt $I11, 0, rx85_fail + inc rx85_pos + (rx85_rep) = rx85_cur."!mark_commit"($I99) + rx85_cur."!mark_push"(rx85_rep, rx85_pos, $I99) goto rxquantr98_loop rxquantr98_done: - alt87_end: -.annotate 'line', 42 + # rx literal "#" + add $I11, rx85_pos, 1 + gt $I11, rx85_eos, rx85_fail + sub $I11, rx85_pos, rx85_off + substr $S10, rx85_tgt, $I11, 1 + ne $S10, "#", rx85_fail + add rx85_pos, 1 + # rx charclass_q N r 0..-1 + sub $I10, rx85_pos, rx85_off + find_cclass $I11, 4096, rx85_tgt, $I10, rx85_eos + add rx85_pos, rx85_off, $I11 + goto alt89_end + alt89_2: +.annotate 'line', 48 + # rx rxquantr100 ** 1..* + set_addr $I101, rxquantr100_done + rx85_cur."!mark_push"(0, -1, $I101) + rxquantr100_loop: + # rx enumcharlist negate=0 + ge rx85_pos, rx85_eos, rx85_fail + sub $I10, rx85_pos, rx85_off + substr $S10, rx85_tgt, $I10, 1 + index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 + lt $I11, 0, rx85_fail + inc rx85_pos + (rx85_rep) = rx85_cur."!mark_commit"($I101) + rx85_cur."!mark_push"(rx85_rep, rx85_pos, $I101) + goto rxquantr100_loop + rxquantr100_done: + alt89_end: +.annotate 'line', 43 # rx pass - rx83_cur."!cursor_pass"(rx83_pos, "unv") - rx83_cur."!cursor_debug"("PASS ", "unv", " at pos=", rx83_pos) - .return (rx83_cur) - rx83_fail: -.annotate 'line', 4 - (rx83_rep, rx83_pos, $I10, $P10) = rx83_cur."!mark_fail"(0) - lt rx83_pos, -1, rx83_done - eq rx83_pos, -1, rx83_fail + rx85_cur."!cursor_pass"(rx85_pos, "unv") + rx85_cur."!cursor_debug"("PASS ", "unv", " at pos=", rx85_pos) + .return (rx85_cur) + rx85_fail: +.annotate 'line', 4 + (rx85_rep, rx85_pos, $I10, $P10) = rx85_cur."!mark_fail"(0) + lt rx85_pos, -1, rx85_done + eq rx85_pos, -1, rx85_fail jump $I10 - rx83_done: - rx83_cur."!cursor_fail"() - rx83_cur."!cursor_debug"("FAIL ", "unv") - .return (rx83_cur) + rx85_done: + rx85_cur."!cursor_fail"() + rx85_cur."!cursor_debug"("FAIL ", "unv") + .return (rx85_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__unv" :subid("24_1275511697.61926") :method +.sub "!PREFIX__unv" :subid("24_1275600007.84296") :method .annotate 'line', 4 - new $P85, "ResizablePMCArray" - push $P85, "" - push $P85, "" - push $P85, "" - .return ($P85) + new $P87, "ResizablePMCArray" + push $P87, "" + push $P87, "" + push $P87, "" + .return ($P87) .end .namespace ["NQP";"Grammar"] -.sub "_block89" :anon :subid("25_1275511697.61926") :method :outer("23_1275511697.61926") -.annotate 'line', 45 - .local string rx91_tgt - .local int rx91_pos - .local int rx91_off - .local int rx91_eos - .local int rx91_rep - .local pmc rx91_cur - (rx91_cur, rx91_pos, rx91_tgt) = self."!cursor_start"() - rx91_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx91_cur +.sub "_block91" :anon :subid("25_1275600007.84296") :method :outer("23_1275600007.84296") +.annotate 'line', 46 + .local string rx93_tgt + .local int rx93_pos + .local int rx93_off + .local int rx93_eos + .local int rx93_rep + .local pmc rx93_cur + (rx93_cur, rx93_pos, rx93_tgt) = self."!cursor_start"() + rx93_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx93_cur .local pmc match .lex "$/", match - length rx91_eos, rx91_tgt - gt rx91_pos, rx91_eos, rx91_done - set rx91_off, 0 - lt rx91_pos, 2, rx91_start - sub rx91_off, rx91_pos, 1 - substr rx91_tgt, rx91_tgt, rx91_off - rx91_start: + length rx93_eos, rx93_tgt + gt rx93_pos, rx93_eos, rx93_done + set rx93_off, 0 + lt rx93_pos, 2, rx93_start + sub rx93_off, rx93_pos, 1 + substr rx93_tgt, rx93_tgt, rx93_off + rx93_start: $I10 = self.'from'() - ne $I10, -1, rxscan92_done - goto rxscan92_scan - rxscan92_loop: - ($P10) = rx91_cur."from"() + ne $I10, -1, rxscan94_done + goto rxscan94_scan + rxscan94_loop: + ($P10) = rx93_cur."from"() inc $P10 - set rx91_pos, $P10 - ge rx91_pos, rx91_eos, rxscan92_done - rxscan92_scan: - set_addr $I10, rxscan92_loop - rx91_cur."!mark_push"(0, rx91_pos, $I10) - rxscan92_done: - # rx rxquantr93 ** 0..* - set_addr $I94, rxquantr93_done - rx91_cur."!mark_push"(0, rx91_pos, $I94) - rxquantr93_loop: + set rx93_pos, $P10 + ge rx93_pos, rx93_eos, rxscan94_done + rxscan94_scan: + set_addr $I10, rxscan94_loop + rx93_cur."!mark_push"(0, rx93_pos, $I10) + rxscan94_done: + # rx rxquantr95 ** 0..* + set_addr $I96, rxquantr95_done + rx93_cur."!mark_push"(0, rx93_pos, $I96) + rxquantr95_loop: # rx enumcharlist negate=0 - ge rx91_pos, rx91_eos, rx91_fail - sub $I10, rx91_pos, rx91_off - substr $S10, rx91_tgt, $I10, 1 + ge rx93_pos, rx93_eos, rx93_fail + sub $I10, rx93_pos, rx93_off + substr $S10, rx93_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx91_fail - inc rx91_pos - (rx91_rep) = rx91_cur."!mark_commit"($I94) - rx91_cur."!mark_push"(rx91_rep, rx91_pos, $I94) - goto rxquantr93_loop - rxquantr93_done: + lt $I11, 0, rx93_fail + inc rx93_pos + (rx93_rep) = rx93_cur."!mark_commit"($I96) + rx93_cur."!mark_push"(rx93_rep, rx93_pos, $I96) + goto rxquantr95_loop + rxquantr95_done: # rx literal "=" - add $I11, rx91_pos, 1 - gt $I11, rx91_eos, rx91_fail - sub $I11, rx91_pos, rx91_off - substr $S10, rx91_tgt, $I11, 1 - ne $S10, "=", rx91_fail - add rx91_pos, 1 - alt95_0: - set_addr $I10, alt95_1 - rx91_cur."!mark_push"(0, rx91_pos, $I10) + add $I11, rx93_pos, 1 + gt $I11, rx93_eos, rx93_fail + sub $I11, rx93_pos, rx93_off + substr $S10, rx93_tgt, $I11, 1 + ne $S10, "=", rx93_fail + add rx93_pos, 1 + alt97_0: + set_addr $I10, alt97_1 + rx93_cur."!mark_push"(0, rx93_pos, $I10) # rx charclass w - ge rx91_pos, rx91_eos, rx91_fail - sub $I10, rx91_pos, rx91_off - is_cclass $I11, 8192, rx91_tgt, $I10 - unless $I11, rx91_fail - inc rx91_pos - goto alt95_end - alt95_1: + ge rx93_pos, rx93_eos, rx93_fail + sub $I10, rx93_pos, rx93_off + is_cclass $I11, 8192, rx93_tgt, $I10 + unless $I11, rx93_fail + inc rx93_pos + goto alt97_end + alt97_1: # rx literal "\\" - add $I11, rx91_pos, 1 - gt $I11, rx91_eos, rx91_fail - sub $I11, rx91_pos, rx91_off - substr $S10, rx91_tgt, $I11, 1 - ne $S10, "\\", rx91_fail - add rx91_pos, 1 - alt95_end: + add $I11, rx93_pos, 1 + gt $I11, rx93_eos, rx93_fail + sub $I11, rx93_pos, rx93_off + substr $S10, rx93_tgt, $I11, 1 + ne $S10, "\\", rx93_fail + add rx93_pos, 1 + alt97_end: # rx pass - rx91_cur."!cursor_pass"(rx91_pos, "") - rx91_cur."!cursor_debug"("PASS ", "", " at pos=", rx91_pos) - .return (rx91_cur) - rx91_fail: - (rx91_rep, rx91_pos, $I10, $P10) = rx91_cur."!mark_fail"(0) - lt rx91_pos, -1, rx91_done - eq rx91_pos, -1, rx91_fail + rx93_cur."!cursor_pass"(rx93_pos, "") + rx93_cur."!cursor_debug"("PASS ", "", " at pos=", rx93_pos) + .return (rx93_cur) + rx93_fail: + (rx93_rep, rx93_pos, $I10, $P10) = rx93_cur."!mark_fail"(0) + lt rx93_pos, -1, rx93_done + eq rx93_pos, -1, rx93_fail jump $I10 - rx91_done: - rx91_cur."!cursor_fail"() - rx91_cur."!cursor_debug"("FAIL ", "") - .return (rx91_cur) + rx93_done: + rx93_cur."!cursor_fail"() + rx93_cur."!cursor_debug"("FAIL ", "") + .return (rx93_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "pod_comment" :subid("26_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "pod_comment" :subid("26_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .const 'Sub' $P141 = "28_1275511697.61926" - capture_lex $P141 - .local string rx101_tgt - .local int rx101_pos - .local int rx101_off - .local int rx101_eos - .local int rx101_rep - .local pmc rx101_cur - (rx101_cur, rx101_pos, rx101_tgt) = self."!cursor_start"() - rx101_cur."!cursor_debug"("START ", "pod_comment") - .lex unicode:"$\x{a2}", rx101_cur + .const 'Sub' $P143 = "28_1275600007.84296" + capture_lex $P143 + .local string rx103_tgt + .local int rx103_pos + .local int rx103_off + .local int rx103_eos + .local int rx103_rep + .local pmc rx103_cur + (rx103_cur, rx103_pos, rx103_tgt) = self."!cursor_start"() + rx103_cur."!cursor_debug"("START ", "pod_comment") + .lex unicode:"$\x{a2}", rx103_cur .local pmc match .lex "$/", match - length rx101_eos, rx101_tgt - gt rx101_pos, rx101_eos, rx101_done - set rx101_off, 0 - lt rx101_pos, 2, rx101_start - sub rx101_off, rx101_pos, 1 - substr rx101_tgt, rx101_tgt, rx101_off - rx101_start: + length rx103_eos, rx103_tgt + gt rx103_pos, rx103_eos, rx103_done + set rx103_off, 0 + lt rx103_pos, 2, rx103_start + sub rx103_off, rx103_pos, 1 + substr rx103_tgt, rx103_tgt, rx103_off + rx103_start: $I10 = self.'from'() - ne $I10, -1, rxscan104_done - goto rxscan104_scan - rxscan104_loop: - ($P10) = rx101_cur."from"() + ne $I10, -1, rxscan106_done + goto rxscan106_scan + rxscan106_loop: + ($P10) = rx103_cur."from"() inc $P10 - set rx101_pos, $P10 - ge rx101_pos, rx101_eos, rxscan104_done - rxscan104_scan: - set_addr $I10, rxscan104_loop - rx101_cur."!mark_push"(0, rx101_pos, $I10) - rxscan104_done: -.annotate 'line', 52 + set rx103_pos, $P10 + ge rx103_pos, rx103_eos, rxscan106_done + rxscan106_scan: + set_addr $I10, rxscan106_loop + rx103_cur."!mark_push"(0, rx103_pos, $I10) + rxscan106_done: +.annotate 'line', 53 # rxanchor bol - eq rx101_pos, 0, rxanchor105_done - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off + eq rx103_pos, 0, rxanchor107_done + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off dec $I10 - is_cclass $I11, 4096, rx101_tgt, $I10 - unless $I11, rx101_fail - rxanchor105_done: - # rx rxquantr106 ** 0..* - set_addr $I107, rxquantr106_done - rx101_cur."!mark_push"(0, rx101_pos, $I107) - rxquantr106_loop: + is_cclass $I11, 4096, rx103_tgt, $I10 + unless $I11, rx103_fail + rxanchor107_done: + # rx rxquantr108 ** 0..* + set_addr $I109, rxquantr108_done + rx103_cur."!mark_push"(0, rx103_pos, $I109) + rxquantr108_loop: # rx enumcharlist negate=0 - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I10, 1 + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx101_fail - inc rx101_pos - (rx101_rep) = rx101_cur."!mark_commit"($I107) - rx101_cur."!mark_push"(rx101_rep, rx101_pos, $I107) - goto rxquantr106_loop - rxquantr106_done: + lt $I11, 0, rx103_fail + inc rx103_pos + (rx103_rep) = rx103_cur."!mark_commit"($I109) + rx103_cur."!mark_push"(rx103_rep, rx103_pos, $I109) + goto rxquantr108_loop + rxquantr108_done: # rx literal "=" - add $I11, rx101_pos, 1 - gt $I11, rx101_eos, rx101_fail - sub $I11, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I11, 1 - ne $S10, "=", rx101_fail - add rx101_pos, 1 - alt108_0: -.annotate 'line', 53 - set_addr $I10, alt108_1 - rx101_cur."!mark_push"(0, rx101_pos, $I10) + add $I11, rx103_pos, 1 + gt $I11, rx103_eos, rx103_fail + sub $I11, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I11, 1 + ne $S10, "=", rx103_fail + add rx103_pos, 1 + alt110_0: .annotate 'line', 54 + set_addr $I10, alt110_1 + rx103_cur."!mark_push"(0, rx103_pos, $I10) +.annotate 'line', 55 # rx literal "begin" - add $I11, rx101_pos, 5 - gt $I11, rx101_eos, rx101_fail - sub $I11, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I11, 5 - ne $S10, "begin", rx101_fail - add rx101_pos, 5 - # rx rxquantr109 ** 1..* - set_addr $I110, rxquantr109_done - rx101_cur."!mark_push"(0, -1, $I110) - rxquantr109_loop: + add $I11, rx103_pos, 5 + gt $I11, rx103_eos, rx103_fail + sub $I11, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I11, 5 + ne $S10, "begin", rx103_fail + add rx103_pos, 5 + # rx rxquantr111 ** 1..* + set_addr $I112, rxquantr111_done + rx103_cur."!mark_push"(0, -1, $I112) + rxquantr111_loop: # rx enumcharlist negate=0 - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I10, 1 + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx101_fail - inc rx101_pos - (rx101_rep) = rx101_cur."!mark_commit"($I110) - rx101_cur."!mark_push"(rx101_rep, rx101_pos, $I110) - goto rxquantr109_loop - rxquantr109_done: + lt $I11, 0, rx103_fail + inc rx103_pos + (rx103_rep) = rx103_cur."!mark_commit"($I112) + rx103_cur."!mark_push"(rx103_rep, rx103_pos, $I112) + goto rxquantr111_loop + rxquantr111_done: # rx literal "END" - add $I11, rx101_pos, 3 - gt $I11, rx101_eos, rx101_fail - sub $I11, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I11, 3 - ne $S10, "END", rx101_fail - add rx101_pos, 3 + add $I11, rx103_pos, 3 + gt $I11, rx103_eos, rx103_fail + sub $I11, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I11, 3 + ne $S10, "END", rx103_fail + add rx103_pos, 3 # rxanchor rwb - le rx101_pos, 0, rx101_fail - sub $I10, rx101_pos, rx101_off - is_cclass $I11, 8192, rx101_tgt, $I10 - if $I11, rx101_fail + le rx103_pos, 0, rx103_fail + sub $I10, rx103_pos, rx103_off + is_cclass $I11, 8192, rx103_tgt, $I10 + if $I11, rx103_fail dec $I10 - is_cclass $I11, 8192, rx101_tgt, $I10 - unless $I11, rx101_fail - alt111_0: -.annotate 'line', 55 - set_addr $I10, alt111_1 - rx101_cur."!mark_push"(0, rx101_pos, $I10) - # rx rxquantf112 ** 0..* - set_addr $I10, rxquantf112_loop - rx101_cur."!mark_push"(0, rx101_pos, $I10) - goto rxquantf112_done - rxquantf112_loop: + is_cclass $I11, 8192, rx103_tgt, $I10 + unless $I11, rx103_fail + alt113_0: +.annotate 'line', 56 + set_addr $I10, alt113_1 + rx103_cur."!mark_push"(0, rx103_pos, $I10) + # rx rxquantf114 ** 0..* + set_addr $I10, rxquantf114_loop + rx103_cur."!mark_push"(0, rx103_pos, $I10) + goto rxquantf114_done + rxquantf114_loop: # rx charclass . - ge rx101_pos, rx101_eos, rx101_fail - inc rx101_pos - set_addr $I10, rxquantf112_loop - rx101_cur."!mark_push"($I113, rx101_pos, $I10) - rxquantf112_done: + ge rx103_pos, rx103_eos, rx103_fail + inc rx103_pos + set_addr $I10, rxquantf114_loop + rx103_cur."!mark_push"($I115, rx103_pos, $I10) + rxquantf114_done: # rx charclass nl - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off - is_cclass $I11, 4096, rx101_tgt, $I10 - unless $I11, rx101_fail - substr $S10, rx101_tgt, $I10, 2 + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off + is_cclass $I11, 4096, rx103_tgt, $I10 + unless $I11, rx103_fail + substr $S10, rx103_tgt, $I10, 2 iseq $I11, $S10, "\r\n" - add rx101_pos, $I11 - inc rx101_pos - # rx rxquantr114 ** 0..* - set_addr $I115, rxquantr114_done - rx101_cur."!mark_push"(0, rx101_pos, $I115) - rxquantr114_loop: - # rx enumcharlist negate=0 - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I10, 1 - index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx101_fail - inc rx101_pos - (rx101_rep) = rx101_cur."!mark_commit"($I115) - rx101_cur."!mark_push"(rx101_rep, rx101_pos, $I115) - goto rxquantr114_loop - rxquantr114_done: - # rx literal "=end" - add $I11, rx101_pos, 4 - gt $I11, rx101_eos, rx101_fail - sub $I11, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I11, 4 - ne $S10, "=end", rx101_fail - add rx101_pos, 4 - # rx rxquantr116 ** 1..* + add rx103_pos, $I11 + inc rx103_pos + # rx rxquantr116 ** 0..* set_addr $I117, rxquantr116_done - rx101_cur."!mark_push"(0, -1, $I117) + rx103_cur."!mark_push"(0, rx103_pos, $I117) rxquantr116_loop: # rx enumcharlist negate=0 - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I10, 1 + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx101_fail - inc rx101_pos - (rx101_rep) = rx101_cur."!mark_commit"($I117) - rx101_cur."!mark_push"(rx101_rep, rx101_pos, $I117) + lt $I11, 0, rx103_fail + inc rx103_pos + (rx103_rep) = rx103_cur."!mark_commit"($I117) + rx103_cur."!mark_push"(rx103_rep, rx103_pos, $I117) goto rxquantr116_loop rxquantr116_done: + # rx literal "=end" + add $I11, rx103_pos, 4 + gt $I11, rx103_eos, rx103_fail + sub $I11, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I11, 4 + ne $S10, "=end", rx103_fail + add rx103_pos, 4 + # rx rxquantr118 ** 1..* + set_addr $I119, rxquantr118_done + rx103_cur."!mark_push"(0, -1, $I119) + rxquantr118_loop: + # rx enumcharlist negate=0 + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I10, 1 + index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 + lt $I11, 0, rx103_fail + inc rx103_pos + (rx103_rep) = rx103_cur."!mark_commit"($I119) + rx103_cur."!mark_push"(rx103_rep, rx103_pos, $I119) + goto rxquantr118_loop + rxquantr118_done: # rx literal "END" - add $I11, rx101_pos, 3 - gt $I11, rx101_eos, rx101_fail - sub $I11, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I11, 3 - ne $S10, "END", rx101_fail - add rx101_pos, 3 + add $I11, rx103_pos, 3 + gt $I11, rx103_eos, rx103_fail + sub $I11, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I11, 3 + ne $S10, "END", rx103_fail + add rx103_pos, 3 # rxanchor rwb - le rx101_pos, 0, rx101_fail - sub $I10, rx101_pos, rx101_off - is_cclass $I11, 8192, rx101_tgt, $I10 - if $I11, rx101_fail + le rx103_pos, 0, rx103_fail + sub $I10, rx103_pos, rx103_off + is_cclass $I11, 8192, rx103_tgt, $I10 + if $I11, rx103_fail dec $I10 - is_cclass $I11, 8192, rx101_tgt, $I10 - unless $I11, rx101_fail + is_cclass $I11, 8192, rx103_tgt, $I10 + unless $I11, rx103_fail # rx charclass_q N r 0..-1 - sub $I10, rx101_pos, rx101_off - find_cclass $I11, 4096, rx101_tgt, $I10, rx101_eos - add rx101_pos, rx101_off, $I11 - goto alt111_end - alt111_1: + sub $I10, rx103_pos, rx103_off + find_cclass $I11, 4096, rx103_tgt, $I10, rx103_eos + add rx103_pos, rx103_off, $I11 + goto alt113_end + alt113_1: # rx charclass_q . r 0..-1 - sub $I10, rx101_pos, rx101_off - find_not_cclass $I11, 65535, rx101_tgt, $I10, rx101_eos - add rx101_pos, rx101_off, $I11 - alt111_end: -.annotate 'line', 54 - goto alt108_end - alt108_1: - set_addr $I10, alt108_2 - rx101_cur."!mark_push"(0, rx101_pos, $I10) -.annotate 'line', 56 + sub $I10, rx103_pos, rx103_off + find_not_cclass $I11, 65535, rx103_tgt, $I10, rx103_eos + add rx103_pos, rx103_off, $I11 + alt113_end: +.annotate 'line', 55 + goto alt110_end + alt110_1: + set_addr $I10, alt110_2 + rx103_cur."!mark_push"(0, rx103_pos, $I10) +.annotate 'line', 57 # rx literal "begin" - add $I11, rx101_pos, 5 - gt $I11, rx101_eos, rx101_fail - sub $I11, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I11, 5 - ne $S10, "begin", rx101_fail - add rx101_pos, 5 - # rx rxquantr118 ** 1..* - set_addr $I119, rxquantr118_done - rx101_cur."!mark_push"(0, -1, $I119) - rxquantr118_loop: + add $I11, rx103_pos, 5 + gt $I11, rx103_eos, rx103_fail + sub $I11, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I11, 5 + ne $S10, "begin", rx103_fail + add rx103_pos, 5 + # rx rxquantr120 ** 1..* + set_addr $I121, rxquantr120_done + rx103_cur."!mark_push"(0, -1, $I121) + rxquantr120_loop: # rx enumcharlist negate=0 - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I10, 1 + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx101_fail - inc rx101_pos - (rx101_rep) = rx101_cur."!mark_commit"($I119) - rx101_cur."!mark_push"(rx101_rep, rx101_pos, $I119) - goto rxquantr118_loop - rxquantr118_done: + lt $I11, 0, rx103_fail + inc rx103_pos + (rx103_rep) = rx103_cur."!mark_commit"($I121) + rx103_cur."!mark_push"(rx103_rep, rx103_pos, $I121) + goto rxquantr120_loop + rxquantr120_done: # rx subrule "identifier" subtype=capture negate= - rx101_cur."!cursor_pos"(rx101_pos) - $P10 = rx101_cur."identifier"() - unless $P10, rx101_fail - rx101_cur."!mark_push"(0, -1, 0, $P10) + rx103_cur."!cursor_pos"(rx103_pos) + $P10 = rx103_cur."identifier"() + unless $P10, rx103_fail + rx103_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("identifier") - rx101_pos = $P10."pos"() - alt120_0: -.annotate 'line', 57 - set_addr $I10, alt120_1 - rx101_cur."!mark_push"(0, rx101_pos, $I10) + rx103_pos = $P10."pos"() + alt122_0: .annotate 'line', 58 - # rx rxquantf121 ** 0..* - set_addr $I10, rxquantf121_loop - rx101_cur."!mark_push"(0, rx101_pos, $I10) - goto rxquantf121_done - rxquantf121_loop: + set_addr $I10, alt122_1 + rx103_cur."!mark_push"(0, rx103_pos, $I10) +.annotate 'line', 59 + # rx rxquantf123 ** 0..* + set_addr $I10, rxquantf123_loop + rx103_cur."!mark_push"(0, rx103_pos, $I10) + goto rxquantf123_done + rxquantf123_loop: # rx charclass . - ge rx101_pos, rx101_eos, rx101_fail - inc rx101_pos - set_addr $I10, rxquantf121_loop - rx101_cur."!mark_push"($I122, rx101_pos, $I10) - rxquantf121_done: + ge rx103_pos, rx103_eos, rx103_fail + inc rx103_pos + set_addr $I10, rxquantf123_loop + rx103_cur."!mark_push"($I124, rx103_pos, $I10) + rxquantf123_done: # rx charclass nl - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off - is_cclass $I11, 4096, rx101_tgt, $I10 - unless $I11, rx101_fail - substr $S10, rx101_tgt, $I10, 2 + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off + is_cclass $I11, 4096, rx103_tgt, $I10 + unless $I11, rx103_fail + substr $S10, rx103_tgt, $I10, 2 iseq $I11, $S10, "\r\n" - add rx101_pos, $I11 - inc rx101_pos - # rx rxquantr123 ** 0..* - set_addr $I124, rxquantr123_done - rx101_cur."!mark_push"(0, rx101_pos, $I124) - rxquantr123_loop: - # rx enumcharlist negate=0 - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I10, 1 - index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx101_fail - inc rx101_pos - (rx101_rep) = rx101_cur."!mark_commit"($I124) - rx101_cur."!mark_push"(rx101_rep, rx101_pos, $I124) - goto rxquantr123_loop - rxquantr123_done: - # rx literal "=end" - add $I11, rx101_pos, 4 - gt $I11, rx101_eos, rx101_fail - sub $I11, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I11, 4 - ne $S10, "=end", rx101_fail - add rx101_pos, 4 - # rx rxquantr125 ** 1..* + add rx103_pos, $I11 + inc rx103_pos + # rx rxquantr125 ** 0..* set_addr $I126, rxquantr125_done - rx101_cur."!mark_push"(0, -1, $I126) + rx103_cur."!mark_push"(0, rx103_pos, $I126) rxquantr125_loop: # rx enumcharlist negate=0 - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I10, 1 + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx101_fail - inc rx101_pos - (rx101_rep) = rx101_cur."!mark_commit"($I126) - rx101_cur."!mark_push"(rx101_rep, rx101_pos, $I126) + lt $I11, 0, rx103_fail + inc rx103_pos + (rx103_rep) = rx103_cur."!mark_commit"($I126) + rx103_cur."!mark_push"(rx103_rep, rx103_pos, $I126) goto rxquantr125_loop rxquantr125_done: + # rx literal "=end" + add $I11, rx103_pos, 4 + gt $I11, rx103_eos, rx103_fail + sub $I11, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I11, 4 + ne $S10, "=end", rx103_fail + add rx103_pos, 4 + # rx rxquantr127 ** 1..* + set_addr $I128, rxquantr127_done + rx103_cur."!mark_push"(0, -1, $I128) + rxquantr127_loop: + # rx enumcharlist negate=0 + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I10, 1 + index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 + lt $I11, 0, rx103_fail + inc rx103_pos + (rx103_rep) = rx103_cur."!mark_commit"($I128) + rx103_cur."!mark_push"(rx103_rep, rx103_pos, $I128) + goto rxquantr127_loop + rxquantr127_done: # rx subrule "!BACKREF" subtype=method negate= - rx101_cur."!cursor_pos"(rx101_pos) - $P10 = rx101_cur."!BACKREF"("identifier") - unless $P10, rx101_fail - rx101_pos = $P10."pos"() + rx103_cur."!cursor_pos"(rx103_pos) + $P10 = rx103_cur."!BACKREF"("identifier") + unless $P10, rx103_fail + rx103_pos = $P10."pos"() # rxanchor rwb - le rx101_pos, 0, rx101_fail - sub $I10, rx101_pos, rx101_off - is_cclass $I11, 8192, rx101_tgt, $I10 - if $I11, rx101_fail + le rx103_pos, 0, rx103_fail + sub $I10, rx103_pos, rx103_off + is_cclass $I11, 8192, rx103_tgt, $I10 + if $I11, rx103_fail dec $I10 - is_cclass $I11, 8192, rx101_tgt, $I10 - unless $I11, rx101_fail + is_cclass $I11, 8192, rx103_tgt, $I10 + unless $I11, rx103_fail # rx charclass_q N r 0..-1 - sub $I10, rx101_pos, rx101_off - find_cclass $I11, 4096, rx101_tgt, $I10, rx101_eos - add rx101_pos, rx101_off, $I11 - goto alt120_end - alt120_1: -.annotate 'line', 59 + sub $I10, rx103_pos, rx103_off + find_cclass $I11, 4096, rx103_tgt, $I10, rx103_eos + add rx103_pos, rx103_off, $I11 + goto alt122_end + alt122_1: +.annotate 'line', 60 # rx subrule "panic" subtype=method negate= - rx101_cur."!cursor_pos"(rx101_pos) - $P10 = rx101_cur."panic"("=begin without matching =end") - unless $P10, rx101_fail - rx101_pos = $P10."pos"() - alt120_end: -.annotate 'line', 56 - goto alt108_end - alt108_2: - set_addr $I10, alt108_3 - rx101_cur."!mark_push"(0, rx101_pos, $I10) -.annotate 'line', 61 + rx103_cur."!cursor_pos"(rx103_pos) + $P10 = rx103_cur."panic"("=begin without matching =end") + unless $P10, rx103_fail + rx103_pos = $P10."pos"() + alt122_end: +.annotate 'line', 57 + goto alt110_end + alt110_2: + set_addr $I10, alt110_3 + rx103_cur."!mark_push"(0, rx103_pos, $I10) +.annotate 'line', 62 # rx literal "begin" - add $I11, rx101_pos, 5 - gt $I11, rx101_eos, rx101_fail - sub $I11, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I11, 5 - ne $S10, "begin", rx101_fail - add rx101_pos, 5 + add $I11, rx103_pos, 5 + gt $I11, rx103_eos, rx103_fail + sub $I11, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I11, 5 + ne $S10, "begin", rx103_fail + add rx103_pos, 5 # rxanchor rwb - le rx101_pos, 0, rx101_fail - sub $I10, rx101_pos, rx101_off - is_cclass $I11, 8192, rx101_tgt, $I10 - if $I11, rx101_fail + le rx103_pos, 0, rx103_fail + sub $I10, rx103_pos, rx103_off + is_cclass $I11, 8192, rx103_tgt, $I10 + if $I11, rx103_fail dec $I10 - is_cclass $I11, 8192, rx101_tgt, $I10 - unless $I11, rx101_fail - # rx rxquantr128 ** 0..* - set_addr $I129, rxquantr128_done - rx101_cur."!mark_push"(0, rx101_pos, $I129) - rxquantr128_loop: + is_cclass $I11, 8192, rx103_tgt, $I10 + unless $I11, rx103_fail + # rx rxquantr130 ** 0..* + set_addr $I131, rxquantr130_done + rx103_cur."!mark_push"(0, rx103_pos, $I131) + rxquantr130_loop: # rx enumcharlist negate=0 - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I10, 1 + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx101_fail - inc rx101_pos - (rx101_rep) = rx101_cur."!mark_commit"($I129) - rx101_cur."!mark_push"(rx101_rep, rx101_pos, $I129) - goto rxquantr128_loop - rxquantr128_done: - alt130_0: -.annotate 'line', 62 - set_addr $I10, alt130_1 - rx101_cur."!mark_push"(0, rx101_pos, $I10) + lt $I11, 0, rx103_fail + inc rx103_pos + (rx103_rep) = rx103_cur."!mark_commit"($I131) + rx103_cur."!mark_push"(rx103_rep, rx103_pos, $I131) + goto rxquantr130_loop + rxquantr130_done: + alt132_0: +.annotate 'line', 63 + set_addr $I10, alt132_1 + rx103_cur."!mark_push"(0, rx103_pos, $I10) # rxanchor eol - sub $I10, rx101_pos, rx101_off - is_cclass $I11, 4096, rx101_tgt, $I10 - if $I11, rxanchor131_done - ne rx101_pos, rx101_eos, rx101_fail - eq rx101_pos, 0, rxanchor131_done + sub $I10, rx103_pos, rx103_off + is_cclass $I11, 4096, rx103_tgt, $I10 + if $I11, rxanchor133_done + ne rx103_pos, rx103_eos, rx103_fail + eq rx103_pos, 0, rxanchor133_done dec $I10 - is_cclass $I11, 4096, rx101_tgt, $I10 - if $I11, rx101_fail - rxanchor131_done: - goto alt130_end - alt130_1: - set_addr $I10, alt130_2 - rx101_cur."!mark_push"(0, rx101_pos, $I10) + is_cclass $I11, 4096, rx103_tgt, $I10 + if $I11, rx103_fail + rxanchor133_done: + goto alt132_end + alt132_1: + set_addr $I10, alt132_2 + rx103_cur."!mark_push"(0, rx103_pos, $I10) # rx literal "#" - add $I11, rx101_pos, 1 - gt $I11, rx101_eos, rx101_fail - sub $I11, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I11, 1 - ne $S10, "#", rx101_fail - add rx101_pos, 1 - goto alt130_end - alt130_2: + add $I11, rx103_pos, 1 + gt $I11, rx103_eos, rx103_fail + sub $I11, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I11, 1 + ne $S10, "#", rx103_fail + add rx103_pos, 1 + goto alt132_end + alt132_2: # rx subrule "panic" subtype=method negate= - rx101_cur."!cursor_pos"(rx101_pos) - $P10 = rx101_cur."panic"("Unrecognized token after =begin") - unless $P10, rx101_fail - rx101_pos = $P10."pos"() - alt130_end: - alt132_0: -.annotate 'line', 63 - set_addr $I10, alt132_1 - rx101_cur."!mark_push"(0, rx101_pos, $I10) + rx103_cur."!cursor_pos"(rx103_pos) + $P10 = rx103_cur."panic"("Unrecognized token after =begin") + unless $P10, rx103_fail + rx103_pos = $P10."pos"() + alt132_end: + alt134_0: .annotate 'line', 64 - # rx rxquantf133 ** 0..* - set_addr $I10, rxquantf133_loop - rx101_cur."!mark_push"(0, rx101_pos, $I10) - goto rxquantf133_done - rxquantf133_loop: + set_addr $I10, alt134_1 + rx103_cur."!mark_push"(0, rx103_pos, $I10) +.annotate 'line', 65 + # rx rxquantf135 ** 0..* + set_addr $I10, rxquantf135_loop + rx103_cur."!mark_push"(0, rx103_pos, $I10) + goto rxquantf135_done + rxquantf135_loop: # rx charclass . - ge rx101_pos, rx101_eos, rx101_fail - inc rx101_pos - set_addr $I10, rxquantf133_loop - rx101_cur."!mark_push"($I134, rx101_pos, $I10) - rxquantf133_done: + ge rx103_pos, rx103_eos, rx103_fail + inc rx103_pos + set_addr $I10, rxquantf135_loop + rx103_cur."!mark_push"($I136, rx103_pos, $I10) + rxquantf135_done: # rx charclass nl - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off - is_cclass $I11, 4096, rx101_tgt, $I10 - unless $I11, rx101_fail - substr $S10, rx101_tgt, $I10, 2 + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off + is_cclass $I11, 4096, rx103_tgt, $I10 + unless $I11, rx103_fail + substr $S10, rx103_tgt, $I10, 2 iseq $I11, $S10, "\r\n" - add rx101_pos, $I11 - inc rx101_pos - # rx rxquantr135 ** 0..* - set_addr $I136, rxquantr135_done - rx101_cur."!mark_push"(0, rx101_pos, $I136) - rxquantr135_loop: + add rx103_pos, $I11 + inc rx103_pos + # rx rxquantr137 ** 0..* + set_addr $I138, rxquantr137_done + rx103_cur."!mark_push"(0, rx103_pos, $I138) + rxquantr137_loop: # rx enumcharlist negate=0 - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I10, 1 + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx101_fail - inc rx101_pos - (rx101_rep) = rx101_cur."!mark_commit"($I136) - rx101_cur."!mark_push"(rx101_rep, rx101_pos, $I136) - goto rxquantr135_loop - rxquantr135_done: + lt $I11, 0, rx103_fail + inc rx103_pos + (rx103_rep) = rx103_cur."!mark_commit"($I138) + rx103_cur."!mark_push"(rx103_rep, rx103_pos, $I138) + goto rxquantr137_loop + rxquantr137_done: # rx literal "=end" - add $I11, rx101_pos, 4 - gt $I11, rx101_eos, rx101_fail - sub $I11, rx101_pos, rx101_off - substr $S10, rx101_tgt, $I11, 4 - ne $S10, "=end", rx101_fail - add rx101_pos, 4 + add $I11, rx103_pos, 4 + gt $I11, rx103_eos, rx103_fail + sub $I11, rx103_pos, rx103_off + substr $S10, rx103_tgt, $I11, 4 + ne $S10, "=end", rx103_fail + add rx103_pos, 4 # rxanchor rwb - le rx101_pos, 0, rx101_fail - sub $I10, rx101_pos, rx101_off - is_cclass $I11, 8192, rx101_tgt, $I10 - if $I11, rx101_fail + le rx103_pos, 0, rx103_fail + sub $I10, rx103_pos, rx103_off + is_cclass $I11, 8192, rx103_tgt, $I10 + if $I11, rx103_fail dec $I10 - is_cclass $I11, 8192, rx101_tgt, $I10 - unless $I11, rx101_fail + is_cclass $I11, 8192, rx103_tgt, $I10 + unless $I11, rx103_fail # rx charclass_q N r 0..-1 - sub $I10, rx101_pos, rx101_off - find_cclass $I11, 4096, rx101_tgt, $I10, rx101_eos - add rx101_pos, rx101_off, $I11 - goto alt132_end - alt132_1: -.annotate 'line', 65 + sub $I10, rx103_pos, rx103_off + find_cclass $I11, 4096, rx103_tgt, $I10, rx103_eos + add rx103_pos, rx103_off, $I11 + goto alt134_end + alt134_1: +.annotate 'line', 66 # rx subrule "panic" subtype=method negate= - rx101_cur."!cursor_pos"(rx101_pos) - $P10 = rx101_cur."panic"("=begin without matching =end") - unless $P10, rx101_fail - rx101_pos = $P10."pos"() - alt132_end: -.annotate 'line', 61 - goto alt108_end - alt108_3: - set_addr $I10, alt108_4 - rx101_cur."!mark_push"(0, rx101_pos, $I10) -.annotate 'line', 67 + rx103_cur."!cursor_pos"(rx103_pos) + $P10 = rx103_cur."panic"("=begin without matching =end") + unless $P10, rx103_fail + rx103_pos = $P10."pos"() + alt134_end: +.annotate 'line', 62 + goto alt110_end + alt110_3: + set_addr $I10, alt110_4 + rx103_cur."!mark_push"(0, rx103_pos, $I10) +.annotate 'line', 68 # rx subrule "identifier" subtype=capture negate= - rx101_cur."!cursor_pos"(rx101_pos) - $P10 = rx101_cur."identifier"() - unless $P10, rx101_fail - rx101_cur."!mark_push"(0, -1, 0, $P10) + rx103_cur."!cursor_pos"(rx103_pos) + $P10 = rx103_cur."identifier"() + unless $P10, rx103_fail + rx103_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("identifier") - rx101_pos = $P10."pos"() -.annotate 'line', 68 - # rx rxquantf137 ** 0..* - set_addr $I10, rxquantf137_loop - rx101_cur."!mark_push"(0, rx101_pos, $I10) - goto rxquantf137_done - rxquantf137_loop: + rx103_pos = $P10."pos"() +.annotate 'line', 69 + # rx rxquantf139 ** 0..* + set_addr $I10, rxquantf139_loop + rx103_cur."!mark_push"(0, rx103_pos, $I10) + goto rxquantf139_done + rxquantf139_loop: # rx charclass . - ge rx101_pos, rx101_eos, rx101_fail - inc rx101_pos - set_addr $I10, rxquantf137_loop - rx101_cur."!mark_push"($I138, rx101_pos, $I10) - rxquantf137_done: + ge rx103_pos, rx103_eos, rx103_fail + inc rx103_pos + set_addr $I10, rxquantf139_loop + rx103_cur."!mark_push"($I140, rx103_pos, $I10) + rxquantf139_done: # rxanchor bol - eq rx101_pos, 0, rxanchor139_done - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off + eq rx103_pos, 0, rxanchor141_done + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off dec $I10 - is_cclass $I11, 4096, rx101_tgt, $I10 - unless $I11, rx101_fail - rxanchor139_done: + is_cclass $I11, 4096, rx103_tgt, $I10 + unless $I11, rx103_fail + rxanchor141_done: # rx subrule "before" subtype=zerowidth negate= - rx101_cur."!cursor_pos"(rx101_pos) - .const 'Sub' $P141 = "28_1275511697.61926" - capture_lex $P141 - $P10 = rx101_cur."before"($P141) - unless $P10, rx101_fail -.annotate 'line', 67 - goto alt108_end - alt108_4: - alt149_0: -.annotate 'line', 74 - set_addr $I10, alt149_1 - rx101_cur."!mark_push"(0, rx101_pos, $I10) + rx103_cur."!cursor_pos"(rx103_pos) + .const 'Sub' $P143 = "28_1275600007.84296" + capture_lex $P143 + $P10 = rx103_cur."before"($P143) + unless $P10, rx103_fail +.annotate 'line', 68 + goto alt110_end + alt110_4: + alt151_0: +.annotate 'line', 75 + set_addr $I10, alt151_1 + rx103_cur."!mark_push"(0, rx103_pos, $I10) # rx charclass s - ge rx101_pos, rx101_eos, rx101_fail - sub $I10, rx101_pos, rx101_off - is_cclass $I11, 32, rx101_tgt, $I10 - unless $I11, rx101_fail - inc rx101_pos - goto alt149_end - alt149_1: + ge rx103_pos, rx103_eos, rx103_fail + sub $I10, rx103_pos, rx103_off + is_cclass $I11, 32, rx103_tgt, $I10 + unless $I11, rx103_fail + inc rx103_pos + goto alt151_end + alt151_1: # rx subrule "panic" subtype=method negate= - rx101_cur."!cursor_pos"(rx101_pos) - $P10 = rx101_cur."panic"("Illegal pod directive") - unless $P10, rx101_fail - rx101_pos = $P10."pos"() - alt149_end: -.annotate 'line', 75 + rx103_cur."!cursor_pos"(rx103_pos) + $P10 = rx103_cur."panic"("Illegal pod directive") + unless $P10, rx103_fail + rx103_pos = $P10."pos"() + alt151_end: +.annotate 'line', 76 # rx charclass_q N r 0..-1 - sub $I10, rx101_pos, rx101_off - find_cclass $I11, 4096, rx101_tgt, $I10, rx101_eos - add rx101_pos, rx101_off, $I11 - alt108_end: -.annotate 'line', 51 + sub $I10, rx103_pos, rx103_off + find_cclass $I11, 4096, rx103_tgt, $I10, rx103_eos + add rx103_pos, rx103_off, $I11 + alt110_end: +.annotate 'line', 52 # rx pass - rx101_cur."!cursor_pass"(rx101_pos, "pod_comment") - rx101_cur."!cursor_debug"("PASS ", "pod_comment", " at pos=", rx101_pos) - .return (rx101_cur) - rx101_fail: -.annotate 'line', 4 - (rx101_rep, rx101_pos, $I10, $P10) = rx101_cur."!mark_fail"(0) - lt rx101_pos, -1, rx101_done - eq rx101_pos, -1, rx101_fail + rx103_cur."!cursor_pass"(rx103_pos, "pod_comment") + rx103_cur."!cursor_debug"("PASS ", "pod_comment", " at pos=", rx103_pos) + .return (rx103_cur) + rx103_fail: +.annotate 'line', 4 + (rx103_rep, rx103_pos, $I10, $P10) = rx103_cur."!mark_fail"(0) + lt rx103_pos, -1, rx103_done + eq rx103_pos, -1, rx103_fail jump $I10 - rx101_done: - rx101_cur."!cursor_fail"() - rx101_cur."!cursor_debug"("FAIL ", "pod_comment") - .return (rx101_cur) + rx103_done: + rx103_cur."!cursor_fail"() + rx103_cur."!cursor_debug"("FAIL ", "pod_comment") + .return (rx103_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__pod_comment" :subid("27_1275511697.61926") :method +.sub "!PREFIX__pod_comment" :subid("27_1275600007.84296") :method .annotate 'line', 4 - new $P103, "ResizablePMCArray" - push $P103, "" - .return ($P103) + new $P105, "ResizablePMCArray" + push $P105, "" + .return ($P105) .end .namespace ["NQP";"Grammar"] -.sub "_block140" :anon :subid("28_1275511697.61926") :method :outer("26_1275511697.61926") -.annotate 'line', 68 - .local string rx142_tgt - .local int rx142_pos - .local int rx142_off - .local int rx142_eos - .local int rx142_rep - .local pmc rx142_cur - (rx142_cur, rx142_pos, rx142_tgt) = self."!cursor_start"() - rx142_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx142_cur +.sub "_block142" :anon :subid("28_1275600007.84296") :method :outer("26_1275600007.84296") +.annotate 'line', 69 + .local string rx144_tgt + .local int rx144_pos + .local int rx144_off + .local int rx144_eos + .local int rx144_rep + .local pmc rx144_cur + (rx144_cur, rx144_pos, rx144_tgt) = self."!cursor_start"() + rx144_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx144_cur .local pmc match .lex "$/", match - length rx142_eos, rx142_tgt - gt rx142_pos, rx142_eos, rx142_done - set rx142_off, 0 - lt rx142_pos, 2, rx142_start - sub rx142_off, rx142_pos, 1 - substr rx142_tgt, rx142_tgt, rx142_off - rx142_start: + length rx144_eos, rx144_tgt + gt rx144_pos, rx144_eos, rx144_done + set rx144_off, 0 + lt rx144_pos, 2, rx144_start + sub rx144_off, rx144_pos, 1 + substr rx144_tgt, rx144_tgt, rx144_off + rx144_start: $I10 = self.'from'() - ne $I10, -1, rxscan143_done - goto rxscan143_scan - rxscan143_loop: - ($P10) = rx142_cur."from"() + ne $I10, -1, rxscan145_done + goto rxscan145_scan + rxscan145_loop: + ($P10) = rx144_cur."from"() inc $P10 - set rx142_pos, $P10 - ge rx142_pos, rx142_eos, rxscan143_done - rxscan143_scan: - set_addr $I10, rxscan143_loop - rx142_cur."!mark_push"(0, rx142_pos, $I10) - rxscan143_done: - # rx rxquantr144 ** 0..* - set_addr $I145, rxquantr144_done - rx142_cur."!mark_push"(0, rx142_pos, $I145) - rxquantr144_loop: + set rx144_pos, $P10 + ge rx144_pos, rx144_eos, rxscan145_done + rxscan145_scan: + set_addr $I10, rxscan145_loop + rx144_cur."!mark_push"(0, rx144_pos, $I10) + rxscan145_done: + # rx rxquantr146 ** 0..* + set_addr $I147, rxquantr146_done + rx144_cur."!mark_push"(0, rx144_pos, $I147) + rxquantr146_loop: # rx enumcharlist negate=0 - ge rx142_pos, rx142_eos, rx142_fail - sub $I10, rx142_pos, rx142_off - substr $S10, rx142_tgt, $I10, 1 + ge rx144_pos, rx144_eos, rx144_fail + sub $I10, rx144_pos, rx144_off + substr $S10, rx144_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx142_fail - inc rx142_pos - (rx142_rep) = rx142_cur."!mark_commit"($I145) - rx142_cur."!mark_push"(rx142_rep, rx142_pos, $I145) - goto rxquantr144_loop - rxquantr144_done: - alt146_0: - set_addr $I10, alt146_1 - rx142_cur."!mark_push"(0, rx142_pos, $I10) -.annotate 'line', 69 + lt $I11, 0, rx144_fail + inc rx144_pos + (rx144_rep) = rx144_cur."!mark_commit"($I147) + rx144_cur."!mark_push"(rx144_rep, rx144_pos, $I147) + goto rxquantr146_loop + rxquantr146_done: + alt148_0: + set_addr $I10, alt148_1 + rx144_cur."!mark_push"(0, rx144_pos, $I10) +.annotate 'line', 70 # rx literal "=" - add $I11, rx142_pos, 1 - gt $I11, rx142_eos, rx142_fail - sub $I11, rx142_pos, rx142_off - substr $S10, rx142_tgt, $I11, 1 - ne $S10, "=", rx142_fail - add rx142_pos, 1 + add $I11, rx144_pos, 1 + gt $I11, rx144_eos, rx144_fail + sub $I11, rx144_pos, rx144_off + substr $S10, rx144_tgt, $I11, 1 + ne $S10, "=", rx144_fail + add rx144_pos, 1 +.annotate 'line', 72 + # rx rxquantr149 ** 0..1 + set_addr $I150, rxquantr149_done + rx144_cur."!mark_push"(0, rx144_pos, $I150) + rxquantr149_loop: .annotate 'line', 71 - # rx rxquantr147 ** 0..1 - set_addr $I148, rxquantr147_done - rx142_cur."!mark_push"(0, rx142_pos, $I148) - rxquantr147_loop: -.annotate 'line', 70 # rx literal "cut" - add $I11, rx142_pos, 3 - gt $I11, rx142_eos, rx142_fail - sub $I11, rx142_pos, rx142_off - substr $S10, rx142_tgt, $I11, 3 - ne $S10, "cut", rx142_fail - add rx142_pos, 3 + add $I11, rx144_pos, 3 + gt $I11, rx144_eos, rx144_fail + sub $I11, rx144_pos, rx144_off + substr $S10, rx144_tgt, $I11, 3 + ne $S10, "cut", rx144_fail + add rx144_pos, 3 # rxanchor rwb - le rx142_pos, 0, rx142_fail - sub $I10, rx142_pos, rx142_off - is_cclass $I11, 8192, rx142_tgt, $I10 - if $I11, rx142_fail + le rx144_pos, 0, rx144_fail + sub $I10, rx144_pos, rx144_off + is_cclass $I11, 8192, rx144_tgt, $I10 + if $I11, rx144_fail dec $I10 - is_cclass $I11, 8192, rx142_tgt, $I10 - unless $I11, rx142_fail -.annotate 'line', 71 - # rx subrule "panic" subtype=method negate= - rx142_cur."!cursor_pos"(rx142_pos) - $P10 = rx142_cur."panic"("Obsolete pod format, please use =begin/=end instead") - unless $P10, rx142_fail - rx142_pos = $P10."pos"() - (rx142_rep) = rx142_cur."!mark_commit"($I148) - rxquantr147_done: -.annotate 'line', 68 - goto alt146_end - alt146_1: + is_cclass $I11, 8192, rx144_tgt, $I10 + unless $I11, rx144_fail .annotate 'line', 72 + # rx subrule "panic" subtype=method negate= + rx144_cur."!cursor_pos"(rx144_pos) + $P10 = rx144_cur."panic"("Obsolete pod format, please use =begin/=end instead") + unless $P10, rx144_fail + rx144_pos = $P10."pos"() + (rx144_rep) = rx144_cur."!mark_commit"($I150) + rxquantr149_done: +.annotate 'line', 69 + goto alt148_end + alt148_1: +.annotate 'line', 73 # rx charclass nl - ge rx142_pos, rx142_eos, rx142_fail - sub $I10, rx142_pos, rx142_off - is_cclass $I11, 4096, rx142_tgt, $I10 - unless $I11, rx142_fail - substr $S10, rx142_tgt, $I10, 2 + ge rx144_pos, rx144_eos, rx144_fail + sub $I10, rx144_pos, rx144_off + is_cclass $I11, 4096, rx144_tgt, $I10 + unless $I11, rx144_fail + substr $S10, rx144_tgt, $I10, 2 iseq $I11, $S10, "\r\n" - add rx142_pos, $I11 - inc rx142_pos - alt146_end: -.annotate 'line', 68 + add rx144_pos, $I11 + inc rx144_pos + alt148_end: +.annotate 'line', 69 # rx pass - rx142_cur."!cursor_pass"(rx142_pos, "") - rx142_cur."!cursor_debug"("PASS ", "", " at pos=", rx142_pos) - .return (rx142_cur) - rx142_fail: - (rx142_rep, rx142_pos, $I10, $P10) = rx142_cur."!mark_fail"(0) - lt rx142_pos, -1, rx142_done - eq rx142_pos, -1, rx142_fail + rx144_cur."!cursor_pass"(rx144_pos, "") + rx144_cur."!cursor_debug"("PASS ", "", " at pos=", rx144_pos) + .return (rx144_cur) + rx144_fail: + (rx144_rep, rx144_pos, $I10, $P10) = rx144_cur."!mark_fail"(0) + lt rx144_pos, -1, rx144_done + eq rx144_pos, -1, rx144_fail jump $I10 - rx142_done: - rx142_cur."!cursor_fail"() - rx142_cur."!cursor_debug"("FAIL ", "") - .return (rx142_cur) + rx144_done: + rx144_cur."!cursor_fail"() + rx144_cur."!cursor_debug"("FAIL ", "") + .return (rx144_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "comp_unit" :subid("29_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "comp_unit" :subid("29_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx151_tgt - .local int rx151_pos - .local int rx151_off - .local int rx151_eos - .local int rx151_rep - .local pmc rx151_cur - (rx151_cur, rx151_pos, rx151_tgt) = self."!cursor_start"() - rx151_cur."!cursor_debug"("START ", "comp_unit") - .lex unicode:"$\x{a2}", rx151_cur + .local string rx153_tgt + .local int rx153_pos + .local int rx153_off + .local int rx153_eos + .local int rx153_rep + .local pmc rx153_cur + (rx153_cur, rx153_pos, rx153_tgt) = self."!cursor_start"() + rx153_cur."!cursor_debug"("START ", "comp_unit") + .lex unicode:"$\x{a2}", rx153_cur .local pmc match .lex "$/", match - length rx151_eos, rx151_tgt - gt rx151_pos, rx151_eos, rx151_done - set rx151_off, 0 - lt rx151_pos, 2, rx151_start - sub rx151_off, rx151_pos, 1 - substr rx151_tgt, rx151_tgt, rx151_off - rx151_start: + length rx153_eos, rx153_tgt + gt rx153_pos, rx153_eos, rx153_done + set rx153_off, 0 + lt rx153_pos, 2, rx153_start + sub rx153_off, rx153_pos, 1 + substr rx153_tgt, rx153_tgt, rx153_off + rx153_start: $I10 = self.'from'() - ne $I10, -1, rxscan155_done - goto rxscan155_scan - rxscan155_loop: - ($P10) = rx151_cur."from"() + ne $I10, -1, rxscan157_done + goto rxscan157_scan + rxscan157_loop: + ($P10) = rx153_cur."from"() inc $P10 - set rx151_pos, $P10 - ge rx151_pos, rx151_eos, rxscan155_done - rxscan155_scan: - set_addr $I10, rxscan155_loop - rx151_cur."!mark_push"(0, rx151_pos, $I10) - rxscan155_done: -.annotate 'line', 83 - # rx subrule "newpad" subtype=method negate= - rx151_cur."!cursor_pos"(rx151_pos) - $P10 = rx151_cur."newpad"() - unless $P10, rx151_fail - rx151_pos = $P10."pos"() + set rx153_pos, $P10 + ge rx153_pos, rx153_eos, rxscan157_done + rxscan157_scan: + set_addr $I10, rxscan157_loop + rx153_cur."!mark_push"(0, rx153_pos, $I10) + rxscan157_done: .annotate 'line', 84 - # rx subrule "outerctx" subtype=method negate= - rx151_cur."!cursor_pos"(rx151_pos) - $P10 = rx151_cur."outerctx"() - unless $P10, rx151_fail - rx151_pos = $P10."pos"() + # rx subrule "newpad" subtype=method negate= + rx153_cur."!cursor_pos"(rx153_pos) + $P10 = rx153_cur."newpad"() + unless $P10, rx153_fail + rx153_pos = $P10."pos"() .annotate 'line', 85 + # rx subrule "outerctx" subtype=method negate= + rx153_cur."!cursor_pos"(rx153_pos) + $P10 = rx153_cur."outerctx"() + unless $P10, rx153_fail + rx153_pos = $P10."pos"() +.annotate 'line', 86 # rx subrule "statementlist" subtype=capture negate= - rx151_cur."!cursor_pos"(rx151_pos) - $P10 = rx151_cur."statementlist"() - unless $P10, rx151_fail - rx151_cur."!mark_push"(0, -1, 0, $P10) + rx153_cur."!cursor_pos"(rx153_pos) + $P10 = rx153_cur."statementlist"() + unless $P10, rx153_fail + rx153_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("statementlist") - rx151_pos = $P10."pos"() - alt156_0: -.annotate 'line', 86 - set_addr $I10, alt156_1 - rx151_cur."!mark_push"(0, rx151_pos, $I10) + rx153_pos = $P10."pos"() + alt158_0: +.annotate 'line', 87 + set_addr $I10, alt158_1 + rx153_cur."!mark_push"(0, rx153_pos, $I10) # rxanchor eos - ne rx151_pos, rx151_eos, rx151_fail - goto alt156_end - alt156_1: + ne rx153_pos, rx153_eos, rx153_fail + goto alt158_end + alt158_1: # rx subrule "panic" subtype=method negate= - rx151_cur."!cursor_pos"(rx151_pos) - $P10 = rx151_cur."panic"("Confused") - unless $P10, rx151_fail - rx151_pos = $P10."pos"() - alt156_end: -.annotate 'line', 82 + rx153_cur."!cursor_pos"(rx153_pos) + $P10 = rx153_cur."panic"("Confused") + unless $P10, rx153_fail + rx153_pos = $P10."pos"() + alt158_end: +.annotate 'line', 83 # rx pass - rx151_cur."!cursor_pass"(rx151_pos, "comp_unit") - rx151_cur."!cursor_debug"("PASS ", "comp_unit", " at pos=", rx151_pos) - .return (rx151_cur) - rx151_fail: -.annotate 'line', 4 - (rx151_rep, rx151_pos, $I10, $P10) = rx151_cur."!mark_fail"(0) - lt rx151_pos, -1, rx151_done - eq rx151_pos, -1, rx151_fail + rx153_cur."!cursor_pass"(rx153_pos, "comp_unit") + rx153_cur."!cursor_debug"("PASS ", "comp_unit", " at pos=", rx153_pos) + .return (rx153_cur) + rx153_fail: +.annotate 'line', 4 + (rx153_rep, rx153_pos, $I10, $P10) = rx153_cur."!mark_fail"(0) + lt rx153_pos, -1, rx153_done + eq rx153_pos, -1, rx153_fail jump $I10 - rx151_done: - rx151_cur."!cursor_fail"() - rx151_cur."!cursor_debug"("FAIL ", "comp_unit") - .return (rx151_cur) + rx153_done: + rx153_cur."!cursor_fail"() + rx153_cur."!cursor_debug"("FAIL ", "comp_unit") + .return (rx153_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__comp_unit" :subid("30_1275511697.61926") :method +.sub "!PREFIX__comp_unit" :subid("30_1275600007.84296") :method .annotate 'line', 4 - $P153 = self."!PREFIX__!subrule"("", "") - new $P154, "ResizablePMCArray" - push $P154, $P153 - .return ($P154) + $P155 = self."!PREFIX__!subrule"("", "") + new $P156, "ResizablePMCArray" + push $P156, $P155 + .return ($P156) .end .namespace ["NQP";"Grammar"] -.sub "statementlist" :subid("31_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statementlist" :subid("31_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx158_tgt - .local int rx158_pos - .local int rx158_off - .local int rx158_eos - .local int rx158_rep - .local pmc rx158_cur - (rx158_cur, rx158_pos, rx158_tgt) = self."!cursor_start"() - rx158_cur."!cursor_debug"("START ", "statementlist") - rx158_cur."!cursor_caparray"("statement") - .lex unicode:"$\x{a2}", rx158_cur + .local string rx160_tgt + .local int rx160_pos + .local int rx160_off + .local int rx160_eos + .local int rx160_rep + .local pmc rx160_cur + (rx160_cur, rx160_pos, rx160_tgt) = self."!cursor_start"() + rx160_cur."!cursor_debug"("START ", "statementlist") + rx160_cur."!cursor_caparray"("statement") + .lex unicode:"$\x{a2}", rx160_cur .local pmc match .lex "$/", match - length rx158_eos, rx158_tgt - gt rx158_pos, rx158_eos, rx158_done - set rx158_off, 0 - lt rx158_pos, 2, rx158_start - sub rx158_off, rx158_pos, 1 - substr rx158_tgt, rx158_tgt, rx158_off - rx158_start: + length rx160_eos, rx160_tgt + gt rx160_pos, rx160_eos, rx160_done + set rx160_off, 0 + lt rx160_pos, 2, rx160_start + sub rx160_off, rx160_pos, 1 + substr rx160_tgt, rx160_tgt, rx160_off + rx160_start: $I10 = self.'from'() - ne $I10, -1, rxscan161_done - goto rxscan161_scan - rxscan161_loop: - ($P10) = rx158_cur."from"() + ne $I10, -1, rxscan163_done + goto rxscan163_scan + rxscan163_loop: + ($P10) = rx160_cur."from"() inc $P10 - set rx158_pos, $P10 - ge rx158_pos, rx158_eos, rxscan161_done - rxscan161_scan: - set_addr $I10, rxscan161_loop - rx158_cur."!mark_push"(0, rx158_pos, $I10) - rxscan161_done: - alt162_0: -.annotate 'line', 89 - set_addr $I10, alt162_1 - rx158_cur."!mark_push"(0, rx158_pos, $I10) + set rx160_pos, $P10 + ge rx160_pos, rx160_eos, rxscan163_done + rxscan163_scan: + set_addr $I10, rxscan163_loop + rx160_cur."!mark_push"(0, rx160_pos, $I10) + rxscan163_done: + alt164_0: .annotate 'line', 90 + set_addr $I10, alt164_1 + rx160_cur."!mark_push"(0, rx160_pos, $I10) +.annotate 'line', 91 # rx subrule "ws" subtype=method negate= - rx158_cur."!cursor_pos"(rx158_pos) - $P10 = rx158_cur."ws"() - unless $P10, rx158_fail - rx158_pos = $P10."pos"() + rx160_cur."!cursor_pos"(rx160_pos) + $P10 = rx160_cur."ws"() + unless $P10, rx160_fail + rx160_pos = $P10."pos"() # rxanchor eos - ne rx158_pos, rx158_eos, rx158_fail + ne rx160_pos, rx160_eos, rx160_fail # rx subrule "ws" subtype=method negate= - rx158_cur."!cursor_pos"(rx158_pos) - $P10 = rx158_cur."ws"() - unless $P10, rx158_fail - rx158_pos = $P10."pos"() - goto alt162_end - alt162_1: -.annotate 'line', 91 + rx160_cur."!cursor_pos"(rx160_pos) + $P10 = rx160_cur."ws"() + unless $P10, rx160_fail + rx160_pos = $P10."pos"() + goto alt164_end + alt164_1: +.annotate 'line', 92 # rx subrule "ws" subtype=method negate= - rx158_cur."!cursor_pos"(rx158_pos) - $P10 = rx158_cur."ws"() - unless $P10, rx158_fail - rx158_pos = $P10."pos"() - # rx rxquantr166 ** 0..* - set_addr $I168, rxquantr166_done - rx158_cur."!mark_push"(0, rx158_pos, $I168) - rxquantr166_loop: + rx160_cur."!cursor_pos"(rx160_pos) + $P10 = rx160_cur."ws"() + unless $P10, rx160_fail + rx160_pos = $P10."pos"() + # rx rxquantr168 ** 0..* + set_addr $I170, rxquantr168_done + rx160_cur."!mark_push"(0, rx160_pos, $I170) + rxquantr168_loop: # rx subrule "statement" subtype=capture negate= - rx158_cur."!cursor_pos"(rx158_pos) - $P10 = rx158_cur."statement"() - unless $P10, rx158_fail - rx158_cur."!mark_push"(0, -1, 0, $P10) + rx160_cur."!cursor_pos"(rx160_pos) + $P10 = rx160_cur."statement"() + unless $P10, rx160_fail + rx160_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("statement") - rx158_pos = $P10."pos"() + rx160_pos = $P10."pos"() # rx subrule "eat_terminator" subtype=method negate= - rx158_cur."!cursor_pos"(rx158_pos) - $P10 = rx158_cur."eat_terminator"() - unless $P10, rx158_fail - rx158_pos = $P10."pos"() + rx160_cur."!cursor_pos"(rx160_pos) + $P10 = rx160_cur."eat_terminator"() + unless $P10, rx160_fail + rx160_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx158_cur."!cursor_pos"(rx158_pos) - $P10 = rx158_cur."ws"() - unless $P10, rx158_fail - rx158_pos = $P10."pos"() - (rx158_rep) = rx158_cur."!mark_commit"($I168) - rx158_cur."!mark_push"(rx158_rep, rx158_pos, $I168) - goto rxquantr166_loop - rxquantr166_done: + rx160_cur."!cursor_pos"(rx160_pos) + $P10 = rx160_cur."ws"() + unless $P10, rx160_fail + rx160_pos = $P10."pos"() + (rx160_rep) = rx160_cur."!mark_commit"($I170) + rx160_cur."!mark_push"(rx160_rep, rx160_pos, $I170) + goto rxquantr168_loop + rxquantr168_done: # rx subrule "ws" subtype=method negate= - rx158_cur."!cursor_pos"(rx158_pos) - $P10 = rx158_cur."ws"() - unless $P10, rx158_fail - rx158_pos = $P10."pos"() - alt162_end: -.annotate 'line', 89 + rx160_cur."!cursor_pos"(rx160_pos) + $P10 = rx160_cur."ws"() + unless $P10, rx160_fail + rx160_pos = $P10."pos"() + alt164_end: +.annotate 'line', 90 # rx pass - rx158_cur."!cursor_pass"(rx158_pos, "statementlist") - rx158_cur."!cursor_debug"("PASS ", "statementlist", " at pos=", rx158_pos) - .return (rx158_cur) - rx158_fail: -.annotate 'line', 4 - (rx158_rep, rx158_pos, $I10, $P10) = rx158_cur."!mark_fail"(0) - lt rx158_pos, -1, rx158_done - eq rx158_pos, -1, rx158_fail + rx160_cur."!cursor_pass"(rx160_pos, "statementlist") + rx160_cur."!cursor_debug"("PASS ", "statementlist", " at pos=", rx160_pos) + .return (rx160_cur) + rx160_fail: +.annotate 'line', 4 + (rx160_rep, rx160_pos, $I10, $P10) = rx160_cur."!mark_fail"(0) + lt rx160_pos, -1, rx160_done + eq rx160_pos, -1, rx160_fail jump $I10 - rx158_done: - rx158_cur."!cursor_fail"() - rx158_cur."!cursor_debug"("FAIL ", "statementlist") - .return (rx158_cur) + rx160_done: + rx160_cur."!cursor_fail"() + rx160_cur."!cursor_debug"("FAIL ", "statementlist") + .return (rx160_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statementlist" :subid("32_1275511697.61926") :method +.sub "!PREFIX__statementlist" :subid("32_1275600007.84296") :method .annotate 'line', 4 - new $P160, "ResizablePMCArray" - push $P160, "" - push $P160, "" - .return ($P160) + new $P162, "ResizablePMCArray" + push $P162, "" + push $P162, "" + .return ($P162) .end .namespace ["NQP";"Grammar"] -.sub "statement" :subid("33_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement" :subid("33_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .const 'Sub' $P176 = "35_1275511697.61926" - capture_lex $P176 - .local string rx171_tgt - .local int rx171_pos - .local int rx171_off - .local int rx171_eos - .local int rx171_rep - .local pmc rx171_cur - (rx171_cur, rx171_pos, rx171_tgt) = self."!cursor_start"() - rx171_cur."!cursor_debug"("START ", "statement") - rx171_cur."!cursor_caparray"("statement_mod_loop", "statement_mod_cond") - .lex unicode:"$\x{a2}", rx171_cur + .const 'Sub' $P178 = "35_1275600007.84296" + capture_lex $P178 + .local string rx173_tgt + .local int rx173_pos + .local int rx173_off + .local int rx173_eos + .local int rx173_rep + .local pmc rx173_cur + (rx173_cur, rx173_pos, rx173_tgt) = self."!cursor_start"() + rx173_cur."!cursor_debug"("START ", "statement") + rx173_cur."!cursor_caparray"("statement_mod_loop", "statement_mod_cond") + .lex unicode:"$\x{a2}", rx173_cur .local pmc match .lex "$/", match - length rx171_eos, rx171_tgt - gt rx171_pos, rx171_eos, rx171_done - set rx171_off, 0 - lt rx171_pos, 2, rx171_start - sub rx171_off, rx171_pos, 1 - substr rx171_tgt, rx171_tgt, rx171_off - rx171_start: + length rx173_eos, rx173_tgt + gt rx173_pos, rx173_eos, rx173_done + set rx173_off, 0 + lt rx173_pos, 2, rx173_start + sub rx173_off, rx173_pos, 1 + substr rx173_tgt, rx173_tgt, rx173_off + rx173_start: $I10 = self.'from'() - ne $I10, -1, rxscan174_done - goto rxscan174_scan - rxscan174_loop: - ($P10) = rx171_cur."from"() + ne $I10, -1, rxscan176_done + goto rxscan176_scan + rxscan176_loop: + ($P10) = rx173_cur."from"() inc $P10 - set rx171_pos, $P10 - ge rx171_pos, rx171_eos, rxscan174_done - rxscan174_scan: - set_addr $I10, rxscan174_loop - rx171_cur."!mark_push"(0, rx171_pos, $I10) - rxscan174_done: -.annotate 'line', 95 - # rx subrule "before" subtype=zerowidth negate=1 - rx171_cur."!cursor_pos"(rx171_pos) - .const 'Sub' $P176 = "35_1275511697.61926" - capture_lex $P176 - $P10 = rx171_cur."before"($P176) - if $P10, rx171_fail - alt180_0: + set rx173_pos, $P10 + ge rx173_pos, rx173_eos, rxscan176_done + rxscan176_scan: + set_addr $I10, rxscan176_loop + rx173_cur."!mark_push"(0, rx173_pos, $I10) + rxscan176_done: .annotate 'line', 96 - set_addr $I10, alt180_1 - rx171_cur."!mark_push"(0, rx171_pos, $I10) + # rx subrule "before" subtype=zerowidth negate=1 + rx173_cur."!cursor_pos"(rx173_pos) + .const 'Sub' $P178 = "35_1275600007.84296" + capture_lex $P178 + $P10 = rx173_cur."before"($P178) + if $P10, rx173_fail + alt182_0: .annotate 'line', 97 + set_addr $I10, alt182_1 + rx173_cur."!mark_push"(0, rx173_pos, $I10) +.annotate 'line', 98 # rx subrule "statement_control" subtype=capture negate= - rx171_cur."!cursor_pos"(rx171_pos) - $P10 = rx171_cur."statement_control"() - unless $P10, rx171_fail - rx171_cur."!mark_push"(0, -1, 0, $P10) + rx173_cur."!cursor_pos"(rx173_pos) + $P10 = rx173_cur."statement_control"() + unless $P10, rx173_fail + rx173_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("statement_control") - rx171_pos = $P10."pos"() - goto alt180_end - alt180_1: -.annotate 'line', 98 + rx173_pos = $P10."pos"() + goto alt182_end + alt182_1: +.annotate 'line', 99 # rx subrule "EXPR" subtype=capture negate= - rx171_cur."!cursor_pos"(rx171_pos) - $P10 = rx171_cur."EXPR"() - unless $P10, rx171_fail - rx171_cur."!mark_push"(0, -1, 0, $P10) + rx173_cur."!cursor_pos"(rx173_pos) + $P10 = rx173_cur."EXPR"() + unless $P10, rx173_fail + rx173_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("EXPR") - rx171_pos = $P10."pos"() + rx173_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx171_cur."!cursor_pos"(rx171_pos) - $P10 = rx171_cur."ws"() - unless $P10, rx171_fail - rx171_pos = $P10."pos"() -.annotate 'line', 103 - # rx rxquantr181 ** 0..1 - set_addr $I185, rxquantr181_done - rx171_cur."!mark_push"(0, rx171_pos, $I185) - rxquantr181_loop: - alt182_0: -.annotate 'line', 99 - set_addr $I10, alt182_1 - rx171_cur."!mark_push"(0, rx171_pos, $I10) + rx173_cur."!cursor_pos"(rx173_pos) + $P10 = rx173_cur."ws"() + unless $P10, rx173_fail + rx173_pos = $P10."pos"() +.annotate 'line', 104 + # rx rxquantr183 ** 0..1 + set_addr $I187, rxquantr183_done + rx173_cur."!mark_push"(0, rx173_pos, $I187) + rxquantr183_loop: + alt184_0: .annotate 'line', 100 - # rx subrule "MARKED" subtype=zerowidth negate= - rx171_cur."!cursor_pos"(rx171_pos) - $P10 = rx171_cur."MARKED"("endstmt") - unless $P10, rx171_fail - goto alt182_end - alt182_1: - set_addr $I10, alt182_2 - rx171_cur."!mark_push"(0, rx171_pos, $I10) + set_addr $I10, alt184_1 + rx173_cur."!mark_push"(0, rx173_pos, $I10) .annotate 'line', 101 + # rx subrule "MARKED" subtype=zerowidth negate= + rx173_cur."!cursor_pos"(rx173_pos) + $P10 = rx173_cur."MARKED"("endstmt") + unless $P10, rx173_fail + goto alt184_end + alt184_1: + set_addr $I10, alt184_2 + rx173_cur."!mark_push"(0, rx173_pos, $I10) +.annotate 'line', 102 # rx subrule "statement_mod_cond" subtype=capture negate= - rx171_cur."!cursor_pos"(rx171_pos) - $P10 = rx171_cur."statement_mod_cond"() - unless $P10, rx171_fail - rx171_cur."!mark_push"(0, -1, 0, $P10) + rx173_cur."!cursor_pos"(rx173_pos) + $P10 = rx173_cur."statement_mod_cond"() + unless $P10, rx173_fail + rx173_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("statement_mod_cond") - rx171_pos = $P10."pos"() - # rx rxquantr183 ** 0..1 - set_addr $I184, rxquantr183_done - rx171_cur."!mark_push"(0, rx171_pos, $I184) - rxquantr183_loop: + rx173_pos = $P10."pos"() + # rx rxquantr185 ** 0..1 + set_addr $I186, rxquantr185_done + rx173_cur."!mark_push"(0, rx173_pos, $I186) + rxquantr185_loop: # rx subrule "statement_mod_loop" subtype=capture negate= - rx171_cur."!cursor_pos"(rx171_pos) - $P10 = rx171_cur."statement_mod_loop"() - unless $P10, rx171_fail - rx171_cur."!mark_push"(0, -1, 0, $P10) + rx173_cur."!cursor_pos"(rx173_pos) + $P10 = rx173_cur."statement_mod_loop"() + unless $P10, rx173_fail + rx173_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("statement_mod_loop") - rx171_pos = $P10."pos"() - (rx171_rep) = rx171_cur."!mark_commit"($I184) - rxquantr183_done: - goto alt182_end - alt182_2: -.annotate 'line', 102 + rx173_pos = $P10."pos"() + (rx173_rep) = rx173_cur."!mark_commit"($I186) + rxquantr185_done: + goto alt184_end + alt184_2: +.annotate 'line', 103 # rx subrule "statement_mod_loop" subtype=capture negate= - rx171_cur."!cursor_pos"(rx171_pos) - $P10 = rx171_cur."statement_mod_loop"() - unless $P10, rx171_fail - rx171_cur."!mark_push"(0, -1, 0, $P10) + rx173_cur."!cursor_pos"(rx173_pos) + $P10 = rx173_cur."statement_mod_loop"() + unless $P10, rx173_fail + rx173_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("statement_mod_loop") - rx171_pos = $P10."pos"() + rx173_pos = $P10."pos"() + alt184_end: +.annotate 'line', 104 + (rx173_rep) = rx173_cur."!mark_commit"($I187) + rxquantr183_done: alt182_end: -.annotate 'line', 103 - (rx171_rep) = rx171_cur."!mark_commit"($I185) - rxquantr181_done: - alt180_end: -.annotate 'line', 94 +.annotate 'line', 95 # rx pass - rx171_cur."!cursor_pass"(rx171_pos, "statement") - rx171_cur."!cursor_debug"("PASS ", "statement", " at pos=", rx171_pos) - .return (rx171_cur) - rx171_fail: -.annotate 'line', 4 - (rx171_rep, rx171_pos, $I10, $P10) = rx171_cur."!mark_fail"(0) - lt rx171_pos, -1, rx171_done - eq rx171_pos, -1, rx171_fail + rx173_cur."!cursor_pass"(rx173_pos, "statement") + rx173_cur."!cursor_debug"("PASS ", "statement", " at pos=", rx173_pos) + .return (rx173_cur) + rx173_fail: +.annotate 'line', 4 + (rx173_rep, rx173_pos, $I10, $P10) = rx173_cur."!mark_fail"(0) + lt rx173_pos, -1, rx173_done + eq rx173_pos, -1, rx173_fail jump $I10 - rx171_done: - rx171_cur."!cursor_fail"() - rx171_cur."!cursor_debug"("FAIL ", "statement") - .return (rx171_cur) + rx173_done: + rx173_cur."!cursor_fail"() + rx173_cur."!cursor_debug"("FAIL ", "statement") + .return (rx173_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement" :subid("34_1275511697.61926") :method +.sub "!PREFIX__statement" :subid("34_1275600007.84296") :method .annotate 'line', 4 - new $P173, "ResizablePMCArray" - push $P173, "" - .return ($P173) + new $P175, "ResizablePMCArray" + push $P175, "" + .return ($P175) .end .namespace ["NQP";"Grammar"] -.sub "_block175" :anon :subid("35_1275511697.61926") :method :outer("33_1275511697.61926") -.annotate 'line', 95 - .local string rx177_tgt - .local int rx177_pos - .local int rx177_off - .local int rx177_eos - .local int rx177_rep - .local pmc rx177_cur - (rx177_cur, rx177_pos, rx177_tgt) = self."!cursor_start"() - rx177_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx177_cur +.sub "_block177" :anon :subid("35_1275600007.84296") :method :outer("33_1275600007.84296") +.annotate 'line', 96 + .local string rx179_tgt + .local int rx179_pos + .local int rx179_off + .local int rx179_eos + .local int rx179_rep + .local pmc rx179_cur + (rx179_cur, rx179_pos, rx179_tgt) = self."!cursor_start"() + rx179_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx179_cur .local pmc match .lex "$/", match - length rx177_eos, rx177_tgt - gt rx177_pos, rx177_eos, rx177_done - set rx177_off, 0 - lt rx177_pos, 2, rx177_start - sub rx177_off, rx177_pos, 1 - substr rx177_tgt, rx177_tgt, rx177_off - rx177_start: + length rx179_eos, rx179_tgt + gt rx179_pos, rx179_eos, rx179_done + set rx179_off, 0 + lt rx179_pos, 2, rx179_start + sub rx179_off, rx179_pos, 1 + substr rx179_tgt, rx179_tgt, rx179_off + rx179_start: $I10 = self.'from'() - ne $I10, -1, rxscan178_done - goto rxscan178_scan - rxscan178_loop: - ($P10) = rx177_cur."from"() + ne $I10, -1, rxscan180_done + goto rxscan180_scan + rxscan180_loop: + ($P10) = rx179_cur."from"() inc $P10 - set rx177_pos, $P10 - ge rx177_pos, rx177_eos, rxscan178_done - rxscan178_scan: - set_addr $I10, rxscan178_loop - rx177_cur."!mark_push"(0, rx177_pos, $I10) - rxscan178_done: - alt179_0: - set_addr $I10, alt179_1 - rx177_cur."!mark_push"(0, rx177_pos, $I10) + set rx179_pos, $P10 + ge rx179_pos, rx179_eos, rxscan180_done + rxscan180_scan: + set_addr $I10, rxscan180_loop + rx179_cur."!mark_push"(0, rx179_pos, $I10) + rxscan180_done: + alt181_0: + set_addr $I10, alt181_1 + rx179_cur."!mark_push"(0, rx179_pos, $I10) # rx enumcharlist negate=0 - ge rx177_pos, rx177_eos, rx177_fail - sub $I10, rx177_pos, rx177_off - substr $S10, rx177_tgt, $I10, 1 + ge rx179_pos, rx179_eos, rx179_fail + sub $I10, rx179_pos, rx179_off + substr $S10, rx179_tgt, $I10, 1 index $I11, "])}", $S10 - lt $I11, 0, rx177_fail - inc rx177_pos - goto alt179_end - alt179_1: + lt $I11, 0, rx179_fail + inc rx179_pos + goto alt181_end + alt181_1: # rxanchor eos - ne rx177_pos, rx177_eos, rx177_fail - alt179_end: + ne rx179_pos, rx179_eos, rx179_fail + alt181_end: # rx pass - rx177_cur."!cursor_pass"(rx177_pos, "") - rx177_cur."!cursor_debug"("PASS ", "", " at pos=", rx177_pos) - .return (rx177_cur) - rx177_fail: - (rx177_rep, rx177_pos, $I10, $P10) = rx177_cur."!mark_fail"(0) - lt rx177_pos, -1, rx177_done - eq rx177_pos, -1, rx177_fail + rx179_cur."!cursor_pass"(rx179_pos, "") + rx179_cur."!cursor_debug"("PASS ", "", " at pos=", rx179_pos) + .return (rx179_cur) + rx179_fail: + (rx179_rep, rx179_pos, $I10, $P10) = rx179_cur."!mark_fail"(0) + lt rx179_pos, -1, rx179_done + eq rx179_pos, -1, rx179_fail jump $I10 - rx177_done: - rx177_cur."!cursor_fail"() - rx177_cur."!cursor_debug"("FAIL ", "") - .return (rx177_cur) + rx179_done: + rx179_cur."!cursor_fail"() + rx179_cur."!cursor_debug"("FAIL ", "") + .return (rx179_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "eat_terminator" :subid("36_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "eat_terminator" :subid("36_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx187_tgt - .local int rx187_pos - .local int rx187_off - .local int rx187_eos - .local int rx187_rep - .local pmc rx187_cur - (rx187_cur, rx187_pos, rx187_tgt) = self."!cursor_start"() - rx187_cur."!cursor_debug"("START ", "eat_terminator") - .lex unicode:"$\x{a2}", rx187_cur + .local string rx189_tgt + .local int rx189_pos + .local int rx189_off + .local int rx189_eos + .local int rx189_rep + .local pmc rx189_cur + (rx189_cur, rx189_pos, rx189_tgt) = self."!cursor_start"() + rx189_cur."!cursor_debug"("START ", "eat_terminator") + .lex unicode:"$\x{a2}", rx189_cur .local pmc match .lex "$/", match - length rx187_eos, rx187_tgt - gt rx187_pos, rx187_eos, rx187_done - set rx187_off, 0 - lt rx187_pos, 2, rx187_start - sub rx187_off, rx187_pos, 1 - substr rx187_tgt, rx187_tgt, rx187_off - rx187_start: + length rx189_eos, rx189_tgt + gt rx189_pos, rx189_eos, rx189_done + set rx189_off, 0 + lt rx189_pos, 2, rx189_start + sub rx189_off, rx189_pos, 1 + substr rx189_tgt, rx189_tgt, rx189_off + rx189_start: $I10 = self.'from'() - ne $I10, -1, rxscan190_done - goto rxscan190_scan - rxscan190_loop: - ($P10) = rx187_cur."from"() + ne $I10, -1, rxscan192_done + goto rxscan192_scan + rxscan192_loop: + ($P10) = rx189_cur."from"() inc $P10 - set rx187_pos, $P10 - ge rx187_pos, rx187_eos, rxscan190_done - rxscan190_scan: - set_addr $I10, rxscan190_loop - rx187_cur."!mark_push"(0, rx187_pos, $I10) - rxscan190_done: - alt191_0: -.annotate 'line', 107 - set_addr $I10, alt191_1 - rx187_cur."!mark_push"(0, rx187_pos, $I10) + set rx189_pos, $P10 + ge rx189_pos, rx189_eos, rxscan192_done + rxscan192_scan: + set_addr $I10, rxscan192_loop + rx189_cur."!mark_push"(0, rx189_pos, $I10) + rxscan192_done: + alt193_0: .annotate 'line', 108 - # rx literal ";" - add $I11, rx187_pos, 1 - gt $I11, rx187_eos, rx187_fail - sub $I11, rx187_pos, rx187_off - substr $S10, rx187_tgt, $I11, 1 - ne $S10, ";", rx187_fail - add rx187_pos, 1 - goto alt191_end - alt191_1: - set_addr $I10, alt191_2 - rx187_cur."!mark_push"(0, rx187_pos, $I10) + set_addr $I10, alt193_1 + rx189_cur."!mark_push"(0, rx189_pos, $I10) .annotate 'line', 109 - # rx subrule "MARKED" subtype=zerowidth negate= - rx187_cur."!cursor_pos"(rx187_pos) - $P10 = rx187_cur."MARKED"("endstmt") - unless $P10, rx187_fail - goto alt191_end - alt191_2: - set_addr $I10, alt191_3 - rx187_cur."!mark_push"(0, rx187_pos, $I10) + # rx literal ";" + add $I11, rx189_pos, 1 + gt $I11, rx189_eos, rx189_fail + sub $I11, rx189_pos, rx189_off + substr $S10, rx189_tgt, $I11, 1 + ne $S10, ";", rx189_fail + add rx189_pos, 1 + goto alt193_end + alt193_1: + set_addr $I10, alt193_2 + rx189_cur."!mark_push"(0, rx189_pos, $I10) .annotate 'line', 110 - # rx subrule "terminator" subtype=zerowidth negate= - rx187_cur."!cursor_pos"(rx187_pos) - $P10 = rx187_cur."terminator"() - unless $P10, rx187_fail - goto alt191_end - alt191_3: + # rx subrule "MARKED" subtype=zerowidth negate= + rx189_cur."!cursor_pos"(rx189_pos) + $P10 = rx189_cur."MARKED"("endstmt") + unless $P10, rx189_fail + goto alt193_end + alt193_2: + set_addr $I10, alt193_3 + rx189_cur."!mark_push"(0, rx189_pos, $I10) .annotate 'line', 111 + # rx subrule "terminator" subtype=zerowidth negate= + rx189_cur."!cursor_pos"(rx189_pos) + $P10 = rx189_cur."terminator"() + unless $P10, rx189_fail + goto alt193_end + alt193_3: +.annotate 'line', 112 # rxanchor eos - ne rx187_pos, rx187_eos, rx187_fail - alt191_end: -.annotate 'line', 107 + ne rx189_pos, rx189_eos, rx189_fail + alt193_end: +.annotate 'line', 108 # rx pass - rx187_cur."!cursor_pass"(rx187_pos, "eat_terminator") - rx187_cur."!cursor_debug"("PASS ", "eat_terminator", " at pos=", rx187_pos) - .return (rx187_cur) - rx187_fail: -.annotate 'line', 4 - (rx187_rep, rx187_pos, $I10, $P10) = rx187_cur."!mark_fail"(0) - lt rx187_pos, -1, rx187_done - eq rx187_pos, -1, rx187_fail + rx189_cur."!cursor_pass"(rx189_pos, "eat_terminator") + rx189_cur."!cursor_debug"("PASS ", "eat_terminator", " at pos=", rx189_pos) + .return (rx189_cur) + rx189_fail: +.annotate 'line', 4 + (rx189_rep, rx189_pos, $I10, $P10) = rx189_cur."!mark_fail"(0) + lt rx189_pos, -1, rx189_done + eq rx189_pos, -1, rx189_fail jump $I10 - rx187_done: - rx187_cur."!cursor_fail"() - rx187_cur."!cursor_debug"("FAIL ", "eat_terminator") - .return (rx187_cur) + rx189_done: + rx189_cur."!cursor_fail"() + rx189_cur."!cursor_debug"("FAIL ", "eat_terminator") + .return (rx189_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__eat_terminator" :subid("37_1275511697.61926") :method +.sub "!PREFIX__eat_terminator" :subid("37_1275600007.84296") :method .annotate 'line', 4 - new $P189, "ResizablePMCArray" - push $P189, "" - push $P189, "" - push $P189, "" - push $P189, ";" - .return ($P189) + new $P191, "ResizablePMCArray" + push $P191, "" + push $P191, "" + push $P191, "" + push $P191, ";" + .return ($P191) .end .namespace ["NQP";"Grammar"] -.sub "xblock" :subid("38_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "xblock" :subid("38_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx193_tgt - .local int rx193_pos - .local int rx193_off - .local int rx193_eos - .local int rx193_rep - .local pmc rx193_cur - (rx193_cur, rx193_pos, rx193_tgt) = self."!cursor_start"() - rx193_cur."!cursor_debug"("START ", "xblock") - .lex unicode:"$\x{a2}", rx193_cur + .local string rx195_tgt + .local int rx195_pos + .local int rx195_off + .local int rx195_eos + .local int rx195_rep + .local pmc rx195_cur + (rx195_cur, rx195_pos, rx195_tgt) = self."!cursor_start"() + rx195_cur."!cursor_debug"("START ", "xblock") + .lex unicode:"$\x{a2}", rx195_cur .local pmc match .lex "$/", match - length rx193_eos, rx193_tgt - gt rx193_pos, rx193_eos, rx193_done - set rx193_off, 0 - lt rx193_pos, 2, rx193_start - sub rx193_off, rx193_pos, 1 - substr rx193_tgt, rx193_tgt, rx193_off - rx193_start: + length rx195_eos, rx195_tgt + gt rx195_pos, rx195_eos, rx195_done + set rx195_off, 0 + lt rx195_pos, 2, rx195_start + sub rx195_off, rx195_pos, 1 + substr rx195_tgt, rx195_tgt, rx195_off + rx195_start: $I10 = self.'from'() - ne $I10, -1, rxscan197_done - goto rxscan197_scan - rxscan197_loop: - ($P10) = rx193_cur."from"() + ne $I10, -1, rxscan199_done + goto rxscan199_scan + rxscan199_loop: + ($P10) = rx195_cur."from"() inc $P10 - set rx193_pos, $P10 - ge rx193_pos, rx193_eos, rxscan197_done - rxscan197_scan: - set_addr $I10, rxscan197_loop - rx193_cur."!mark_push"(0, rx193_pos, $I10) - rxscan197_done: -.annotate 'line', 115 + set rx195_pos, $P10 + ge rx195_pos, rx195_eos, rxscan199_done + rxscan199_scan: + set_addr $I10, rxscan199_loop + rx195_cur."!mark_push"(0, rx195_pos, $I10) + rxscan199_done: +.annotate 'line', 116 # rx subrule "EXPR" subtype=capture negate= - rx193_cur."!cursor_pos"(rx193_pos) - $P10 = rx193_cur."EXPR"() - unless $P10, rx193_fail - rx193_cur."!mark_push"(0, -1, 0, $P10) + rx195_cur."!cursor_pos"(rx195_pos) + $P10 = rx195_cur."EXPR"() + unless $P10, rx195_fail + rx195_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("EXPR") - rx193_pos = $P10."pos"() + rx195_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx193_cur."!cursor_pos"(rx193_pos) - $P10 = rx193_cur."ws"() - unless $P10, rx193_fail - rx193_pos = $P10."pos"() + rx195_cur."!cursor_pos"(rx195_pos) + $P10 = rx195_cur."ws"() + unless $P10, rx195_fail + rx195_pos = $P10."pos"() # rx subrule "pblock" subtype=capture negate= - rx193_cur."!cursor_pos"(rx193_pos) - $P10 = rx193_cur."pblock"() - unless $P10, rx193_fail - rx193_cur."!mark_push"(0, -1, 0, $P10) + rx195_cur."!cursor_pos"(rx195_pos) + $P10 = rx195_cur."pblock"() + unless $P10, rx195_fail + rx195_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("pblock") - rx193_pos = $P10."pos"() -.annotate 'line', 114 + rx195_pos = $P10."pos"() +.annotate 'line', 115 # rx pass - rx193_cur."!cursor_pass"(rx193_pos, "xblock") - rx193_cur."!cursor_debug"("PASS ", "xblock", " at pos=", rx193_pos) - .return (rx193_cur) - rx193_fail: -.annotate 'line', 4 - (rx193_rep, rx193_pos, $I10, $P10) = rx193_cur."!mark_fail"(0) - lt rx193_pos, -1, rx193_done - eq rx193_pos, -1, rx193_fail + rx195_cur."!cursor_pass"(rx195_pos, "xblock") + rx195_cur."!cursor_debug"("PASS ", "xblock", " at pos=", rx195_pos) + .return (rx195_cur) + rx195_fail: +.annotate 'line', 4 + (rx195_rep, rx195_pos, $I10, $P10) = rx195_cur."!mark_fail"(0) + lt rx195_pos, -1, rx195_done + eq rx195_pos, -1, rx195_fail jump $I10 - rx193_done: - rx193_cur."!cursor_fail"() - rx193_cur."!cursor_debug"("FAIL ", "xblock") - .return (rx193_cur) + rx195_done: + rx195_cur."!cursor_fail"() + rx195_cur."!cursor_debug"("FAIL ", "xblock") + .return (rx195_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__xblock" :subid("39_1275511697.61926") :method +.sub "!PREFIX__xblock" :subid("39_1275600007.84296") :method .annotate 'line', 4 - $P195 = self."!PREFIX__!subrule"("EXPR", "") - new $P196, "ResizablePMCArray" - push $P196, $P195 - .return ($P196) + $P197 = self."!PREFIX__!subrule"("EXPR", "") + new $P198, "ResizablePMCArray" + push $P198, $P197 + .return ($P198) .end .namespace ["NQP";"Grammar"] -.sub "pblock" :subid("40_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "pblock" :subid("40_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx199_tgt - .local int rx199_pos - .local int rx199_off - .local int rx199_eos - .local int rx199_rep - .local pmc rx199_cur - (rx199_cur, rx199_pos, rx199_tgt) = self."!cursor_start"() - rx199_cur."!cursor_debug"("START ", "pblock") - .lex unicode:"$\x{a2}", rx199_cur + .local string rx201_tgt + .local int rx201_pos + .local int rx201_off + .local int rx201_eos + .local int rx201_rep + .local pmc rx201_cur + (rx201_cur, rx201_pos, rx201_tgt) = self."!cursor_start"() + rx201_cur."!cursor_debug"("START ", "pblock") + .lex unicode:"$\x{a2}", rx201_cur .local pmc match .lex "$/", match - length rx199_eos, rx199_tgt - gt rx199_pos, rx199_eos, rx199_done - set rx199_off, 0 - lt rx199_pos, 2, rx199_start - sub rx199_off, rx199_pos, 1 - substr rx199_tgt, rx199_tgt, rx199_off - rx199_start: + length rx201_eos, rx201_tgt + gt rx201_pos, rx201_eos, rx201_done + set rx201_off, 0 + lt rx201_pos, 2, rx201_start + sub rx201_off, rx201_pos, 1 + substr rx201_tgt, rx201_tgt, rx201_off + rx201_start: $I10 = self.'from'() - ne $I10, -1, rxscan204_done - goto rxscan204_scan - rxscan204_loop: - ($P10) = rx199_cur."from"() + ne $I10, -1, rxscan206_done + goto rxscan206_scan + rxscan206_loop: + ($P10) = rx201_cur."from"() inc $P10 - set rx199_pos, $P10 - ge rx199_pos, rx199_eos, rxscan204_done - rxscan204_scan: - set_addr $I10, rxscan204_loop - rx199_cur."!mark_push"(0, rx199_pos, $I10) - rxscan204_done: - alt205_0: -.annotate 'line', 118 - set_addr $I10, alt205_1 - rx199_cur."!mark_push"(0, rx199_pos, $I10) + set rx201_pos, $P10 + ge rx201_pos, rx201_eos, rxscan206_done + rxscan206_scan: + set_addr $I10, rxscan206_loop + rx201_cur."!mark_push"(0, rx201_pos, $I10) + rxscan206_done: + alt207_0: .annotate 'line', 119 - # rx subrule "lambda" subtype=method negate= - rx199_cur."!cursor_pos"(rx199_pos) - $P10 = rx199_cur."lambda"() - unless $P10, rx199_fail - rx199_pos = $P10."pos"() + set_addr $I10, alt207_1 + rx201_cur."!mark_push"(0, rx201_pos, $I10) .annotate 'line', 120 - # rx subrule "newpad" subtype=method negate= - rx199_cur."!cursor_pos"(rx199_pos) - $P10 = rx199_cur."newpad"() - unless $P10, rx199_fail - rx199_pos = $P10."pos"() + # rx subrule "lambda" subtype=method negate= + rx201_cur."!cursor_pos"(rx201_pos) + $P10 = rx201_cur."lambda"() + unless $P10, rx201_fail + rx201_pos = $P10."pos"() .annotate 'line', 121 + # rx subrule "newpad" subtype=method negate= + rx201_cur."!cursor_pos"(rx201_pos) + $P10 = rx201_cur."newpad"() + unless $P10, rx201_fail + rx201_pos = $P10."pos"() +.annotate 'line', 122 # rx subrule "signature" subtype=capture negate= - rx199_cur."!cursor_pos"(rx199_pos) - $P10 = rx199_cur."signature"() - unless $P10, rx199_fail - rx199_cur."!mark_push"(0, -1, 0, $P10) + rx201_cur."!cursor_pos"(rx201_pos) + $P10 = rx201_cur."signature"() + unless $P10, rx201_fail + rx201_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("signature") - rx199_pos = $P10."pos"() -.annotate 'line', 122 + rx201_pos = $P10."pos"() +.annotate 'line', 123 # rx subrule "blockoid" subtype=capture negate= - rx199_cur."!cursor_pos"(rx199_pos) - $P10 = rx199_cur."blockoid"() - unless $P10, rx199_fail - rx199_cur."!mark_push"(0, -1, 0, $P10) + rx201_cur."!cursor_pos"(rx201_pos) + $P10 = rx201_cur."blockoid"() + unless $P10, rx201_fail + rx201_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("blockoid") - rx199_pos = $P10."pos"() -.annotate 'line', 119 - goto alt205_end - alt205_1: - set_addr $I10, alt205_2 - rx199_cur."!mark_push"(0, rx199_pos, $I10) -.annotate 'line', 123 + rx201_pos = $P10."pos"() +.annotate 'line', 120 + goto alt207_end + alt207_1: + set_addr $I10, alt207_2 + rx201_cur."!mark_push"(0, rx201_pos, $I10) +.annotate 'line', 124 # rx enumcharlist negate=0 zerowidth - ge rx199_pos, rx199_eos, rx199_fail - sub $I10, rx199_pos, rx199_off - substr $S10, rx199_tgt, $I10, 1 + ge rx201_pos, rx201_eos, rx201_fail + sub $I10, rx201_pos, rx201_off + substr $S10, rx201_tgt, $I10, 1 index $I11, "{", $S10 - lt $I11, 0, rx199_fail -.annotate 'line', 124 - # rx subrule "newpad" subtype=method negate= - rx199_cur."!cursor_pos"(rx199_pos) - $P10 = rx199_cur."newpad"() - unless $P10, rx199_fail - rx199_pos = $P10."pos"() + lt $I11, 0, rx201_fail .annotate 'line', 125 + # rx subrule "newpad" subtype=method negate= + rx201_cur."!cursor_pos"(rx201_pos) + $P10 = rx201_cur."newpad"() + unless $P10, rx201_fail + rx201_pos = $P10."pos"() +.annotate 'line', 126 # rx subrule "blockoid" subtype=capture negate= - rx199_cur."!cursor_pos"(rx199_pos) - $P10 = rx199_cur."blockoid"() - unless $P10, rx199_fail - rx199_cur."!mark_push"(0, -1, 0, $P10) + rx201_cur."!cursor_pos"(rx201_pos) + $P10 = rx201_cur."blockoid"() + unless $P10, rx201_fail + rx201_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("blockoid") - rx199_pos = $P10."pos"() -.annotate 'line', 123 - goto alt205_end - alt205_2: -.annotate 'line', 126 + rx201_pos = $P10."pos"() +.annotate 'line', 124 + goto alt207_end + alt207_2: +.annotate 'line', 127 # rx subrule "panic" subtype=method negate= - rx199_cur."!cursor_pos"(rx199_pos) - $P10 = rx199_cur."panic"("Missing block") - unless $P10, rx199_fail - rx199_pos = $P10."pos"() - alt205_end: -.annotate 'line', 118 + rx201_cur."!cursor_pos"(rx201_pos) + $P10 = rx201_cur."panic"("Missing block") + unless $P10, rx201_fail + rx201_pos = $P10."pos"() + alt207_end: +.annotate 'line', 119 # rx pass - rx199_cur."!cursor_pass"(rx199_pos, "pblock") - rx199_cur."!cursor_debug"("PASS ", "pblock", " at pos=", rx199_pos) - .return (rx199_cur) - rx199_fail: -.annotate 'line', 4 - (rx199_rep, rx199_pos, $I10, $P10) = rx199_cur."!mark_fail"(0) - lt rx199_pos, -1, rx199_done - eq rx199_pos, -1, rx199_fail + rx201_cur."!cursor_pass"(rx201_pos, "pblock") + rx201_cur."!cursor_debug"("PASS ", "pblock", " at pos=", rx201_pos) + .return (rx201_cur) + rx201_fail: +.annotate 'line', 4 + (rx201_rep, rx201_pos, $I10, $P10) = rx201_cur."!mark_fail"(0) + lt rx201_pos, -1, rx201_done + eq rx201_pos, -1, rx201_fail jump $I10 - rx199_done: - rx199_cur."!cursor_fail"() - rx199_cur."!cursor_debug"("FAIL ", "pblock") - .return (rx199_cur) + rx201_done: + rx201_cur."!cursor_fail"() + rx201_cur."!cursor_debug"("FAIL ", "pblock") + .return (rx201_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__pblock" :subid("41_1275511697.61926") :method +.sub "!PREFIX__pblock" :subid("41_1275600007.84296") :method .annotate 'line', 4 - $P201 = self."!PREFIX__!subrule"("", "") - $P202 = self."!PREFIX__!subrule"("", "") - new $P203, "ResizablePMCArray" - push $P203, $P201 - push $P203, "{" - push $P203, $P202 - .return ($P203) + $P203 = self."!PREFIX__!subrule"("", "") + $P204 = self."!PREFIX__!subrule"("", "") + new $P205, "ResizablePMCArray" + push $P205, $P203 + push $P205, "{" + push $P205, $P204 + .return ($P205) .end .namespace ["NQP";"Grammar"] -.sub "lambda" :subid("42_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "lambda" :subid("42_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx207_tgt - .local int rx207_pos - .local int rx207_off - .local int rx207_eos - .local int rx207_rep - .local pmc rx207_cur - (rx207_cur, rx207_pos, rx207_tgt) = self."!cursor_start"() - rx207_cur."!cursor_debug"("START ", "lambda") - .lex unicode:"$\x{a2}", rx207_cur + .local string rx209_tgt + .local int rx209_pos + .local int rx209_off + .local int rx209_eos + .local int rx209_rep + .local pmc rx209_cur + (rx209_cur, rx209_pos, rx209_tgt) = self."!cursor_start"() + rx209_cur."!cursor_debug"("START ", "lambda") + .lex unicode:"$\x{a2}", rx209_cur .local pmc match .lex "$/", match - length rx207_eos, rx207_tgt - gt rx207_pos, rx207_eos, rx207_done - set rx207_off, 0 - lt rx207_pos, 2, rx207_start - sub rx207_off, rx207_pos, 1 - substr rx207_tgt, rx207_tgt, rx207_off - rx207_start: + length rx209_eos, rx209_tgt + gt rx209_pos, rx209_eos, rx209_done + set rx209_off, 0 + lt rx209_pos, 2, rx209_start + sub rx209_off, rx209_pos, 1 + substr rx209_tgt, rx209_tgt, rx209_off + rx209_start: $I10 = self.'from'() - ne $I10, -1, rxscan210_done - goto rxscan210_scan - rxscan210_loop: - ($P10) = rx207_cur."from"() + ne $I10, -1, rxscan212_done + goto rxscan212_scan + rxscan212_loop: + ($P10) = rx209_cur."from"() inc $P10 - set rx207_pos, $P10 - ge rx207_pos, rx207_eos, rxscan210_done - rxscan210_scan: - set_addr $I10, rxscan210_loop - rx207_cur."!mark_push"(0, rx207_pos, $I10) - rxscan210_done: - alt211_0: -.annotate 'line', 129 - set_addr $I10, alt211_1 - rx207_cur."!mark_push"(0, rx207_pos, $I10) + set rx209_pos, $P10 + ge rx209_pos, rx209_eos, rxscan212_done + rxscan212_scan: + set_addr $I10, rxscan212_loop + rx209_cur."!mark_push"(0, rx209_pos, $I10) + rxscan212_done: + alt213_0: +.annotate 'line', 130 + set_addr $I10, alt213_1 + rx209_cur."!mark_push"(0, rx209_pos, $I10) # rx literal "->" - add $I11, rx207_pos, 2 - gt $I11, rx207_eos, rx207_fail - sub $I11, rx207_pos, rx207_off - substr $S10, rx207_tgt, $I11, 2 - ne $S10, "->", rx207_fail - add rx207_pos, 2 - goto alt211_end - alt211_1: + add $I11, rx209_pos, 2 + gt $I11, rx209_eos, rx209_fail + sub $I11, rx209_pos, rx209_off + substr $S10, rx209_tgt, $I11, 2 + ne $S10, "->", rx209_fail + add rx209_pos, 2 + goto alt213_end + alt213_1: # rx literal "<->" - add $I11, rx207_pos, 3 - gt $I11, rx207_eos, rx207_fail - sub $I11, rx207_pos, rx207_off - substr $S10, rx207_tgt, $I11, 3 - ne $S10, "<->", rx207_fail - add rx207_pos, 3 - alt211_end: + add $I11, rx209_pos, 3 + gt $I11, rx209_eos, rx209_fail + sub $I11, rx209_pos, rx209_off + substr $S10, rx209_tgt, $I11, 3 + ne $S10, "<->", rx209_fail + add rx209_pos, 3 + alt213_end: # rx pass - rx207_cur."!cursor_pass"(rx207_pos, "lambda") - rx207_cur."!cursor_debug"("PASS ", "lambda", " at pos=", rx207_pos) - .return (rx207_cur) - rx207_fail: -.annotate 'line', 4 - (rx207_rep, rx207_pos, $I10, $P10) = rx207_cur."!mark_fail"(0) - lt rx207_pos, -1, rx207_done - eq rx207_pos, -1, rx207_fail + rx209_cur."!cursor_pass"(rx209_pos, "lambda") + rx209_cur."!cursor_debug"("PASS ", "lambda", " at pos=", rx209_pos) + .return (rx209_cur) + rx209_fail: +.annotate 'line', 4 + (rx209_rep, rx209_pos, $I10, $P10) = rx209_cur."!mark_fail"(0) + lt rx209_pos, -1, rx209_done + eq rx209_pos, -1, rx209_fail jump $I10 - rx207_done: - rx207_cur."!cursor_fail"() - rx207_cur."!cursor_debug"("FAIL ", "lambda") - .return (rx207_cur) + rx209_done: + rx209_cur."!cursor_fail"() + rx209_cur."!cursor_debug"("FAIL ", "lambda") + .return (rx209_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__lambda" :subid("43_1275511697.61926") :method +.sub "!PREFIX__lambda" :subid("43_1275600007.84296") :method .annotate 'line', 4 - new $P209, "ResizablePMCArray" - push $P209, "<->" - push $P209, "->" - .return ($P209) + new $P211, "ResizablePMCArray" + push $P211, "<->" + push $P211, "->" + .return ($P211) .end .namespace ["NQP";"Grammar"] -.sub "block" :subid("44_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "block" :subid("44_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx213_tgt - .local int rx213_pos - .local int rx213_off - .local int rx213_eos - .local int rx213_rep - .local pmc rx213_cur - (rx213_cur, rx213_pos, rx213_tgt) = self."!cursor_start"() - rx213_cur."!cursor_debug"("START ", "block") - .lex unicode:"$\x{a2}", rx213_cur + .local string rx215_tgt + .local int rx215_pos + .local int rx215_off + .local int rx215_eos + .local int rx215_rep + .local pmc rx215_cur + (rx215_cur, rx215_pos, rx215_tgt) = self."!cursor_start"() + rx215_cur."!cursor_debug"("START ", "block") + .lex unicode:"$\x{a2}", rx215_cur .local pmc match .lex "$/", match - length rx213_eos, rx213_tgt - gt rx213_pos, rx213_eos, rx213_done - set rx213_off, 0 - lt rx213_pos, 2, rx213_start - sub rx213_off, rx213_pos, 1 - substr rx213_tgt, rx213_tgt, rx213_off - rx213_start: + length rx215_eos, rx215_tgt + gt rx215_pos, rx215_eos, rx215_done + set rx215_off, 0 + lt rx215_pos, 2, rx215_start + sub rx215_off, rx215_pos, 1 + substr rx215_tgt, rx215_tgt, rx215_off + rx215_start: $I10 = self.'from'() - ne $I10, -1, rxscan217_done - goto rxscan217_scan - rxscan217_loop: - ($P10) = rx213_cur."from"() + ne $I10, -1, rxscan219_done + goto rxscan219_scan + rxscan219_loop: + ($P10) = rx215_cur."from"() inc $P10 - set rx213_pos, $P10 - ge rx213_pos, rx213_eos, rxscan217_done - rxscan217_scan: - set_addr $I10, rxscan217_loop - rx213_cur."!mark_push"(0, rx213_pos, $I10) - rxscan217_done: - alt218_0: -.annotate 'line', 132 - set_addr $I10, alt218_1 - rx213_cur."!mark_push"(0, rx213_pos, $I10) + set rx215_pos, $P10 + ge rx215_pos, rx215_eos, rxscan219_done + rxscan219_scan: + set_addr $I10, rxscan219_loop + rx215_cur."!mark_push"(0, rx215_pos, $I10) + rxscan219_done: + alt220_0: +.annotate 'line', 133 + set_addr $I10, alt220_1 + rx215_cur."!mark_push"(0, rx215_pos, $I10) # rx enumcharlist negate=0 zerowidth - ge rx213_pos, rx213_eos, rx213_fail - sub $I10, rx213_pos, rx213_off - substr $S10, rx213_tgt, $I10, 1 + ge rx215_pos, rx215_eos, rx215_fail + sub $I10, rx215_pos, rx215_off + substr $S10, rx215_tgt, $I10, 1 index $I11, "{", $S10 - lt $I11, 0, rx213_fail - goto alt218_end - alt218_1: + lt $I11, 0, rx215_fail + goto alt220_end + alt220_1: # rx subrule "panic" subtype=method negate= - rx213_cur."!cursor_pos"(rx213_pos) - $P10 = rx213_cur."panic"("Missing block") - unless $P10, rx213_fail - rx213_pos = $P10."pos"() - alt218_end: -.annotate 'line', 133 - # rx subrule "newpad" subtype=method negate= - rx213_cur."!cursor_pos"(rx213_pos) - $P10 = rx213_cur."newpad"() - unless $P10, rx213_fail - rx213_pos = $P10."pos"() + rx215_cur."!cursor_pos"(rx215_pos) + $P10 = rx215_cur."panic"("Missing block") + unless $P10, rx215_fail + rx215_pos = $P10."pos"() + alt220_end: .annotate 'line', 134 + # rx subrule "newpad" subtype=method negate= + rx215_cur."!cursor_pos"(rx215_pos) + $P10 = rx215_cur."newpad"() + unless $P10, rx215_fail + rx215_pos = $P10."pos"() +.annotate 'line', 135 # rx subrule "blockoid" subtype=capture negate= - rx213_cur."!cursor_pos"(rx213_pos) - $P10 = rx213_cur."blockoid"() - unless $P10, rx213_fail - rx213_cur."!mark_push"(0, -1, 0, $P10) + rx215_cur."!cursor_pos"(rx215_pos) + $P10 = rx215_cur."blockoid"() + unless $P10, rx215_fail + rx215_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("blockoid") - rx213_pos = $P10."pos"() -.annotate 'line', 131 + rx215_pos = $P10."pos"() +.annotate 'line', 132 # rx pass - rx213_cur."!cursor_pass"(rx213_pos, "block") - rx213_cur."!cursor_debug"("PASS ", "block", " at pos=", rx213_pos) - .return (rx213_cur) - rx213_fail: -.annotate 'line', 4 - (rx213_rep, rx213_pos, $I10, $P10) = rx213_cur."!mark_fail"(0) - lt rx213_pos, -1, rx213_done - eq rx213_pos, -1, rx213_fail + rx215_cur."!cursor_pass"(rx215_pos, "block") + rx215_cur."!cursor_debug"("PASS ", "block", " at pos=", rx215_pos) + .return (rx215_cur) + rx215_fail: +.annotate 'line', 4 + (rx215_rep, rx215_pos, $I10, $P10) = rx215_cur."!mark_fail"(0) + lt rx215_pos, -1, rx215_done + eq rx215_pos, -1, rx215_fail jump $I10 - rx213_done: - rx213_cur."!cursor_fail"() - rx213_cur."!cursor_debug"("FAIL ", "block") - .return (rx213_cur) + rx215_done: + rx215_cur."!cursor_fail"() + rx215_cur."!cursor_debug"("FAIL ", "block") + .return (rx215_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__block" :subid("45_1275511697.61926") :method +.sub "!PREFIX__block" :subid("45_1275600007.84296") :method .annotate 'line', 4 - $P215 = self."!PREFIX__!subrule"("", "") - new $P216, "ResizablePMCArray" - push $P216, $P215 - push $P216, "{" - .return ($P216) + $P217 = self."!PREFIX__!subrule"("", "") + new $P218, "ResizablePMCArray" + push $P218, $P217 + push $P218, "{" + .return ($P218) .end .namespace ["NQP";"Grammar"] -.sub "blockoid" :subid("46_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "blockoid" :subid("46_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx220_tgt - .local int rx220_pos - .local int rx220_off - .local int rx220_eos - .local int rx220_rep - .local pmc rx220_cur - (rx220_cur, rx220_pos, rx220_tgt) = self."!cursor_start"() - rx220_cur."!cursor_debug"("START ", "blockoid") - .lex unicode:"$\x{a2}", rx220_cur + .local string rx222_tgt + .local int rx222_pos + .local int rx222_off + .local int rx222_eos + .local int rx222_rep + .local pmc rx222_cur + (rx222_cur, rx222_pos, rx222_tgt) = self."!cursor_start"() + rx222_cur."!cursor_debug"("START ", "blockoid") + .lex unicode:"$\x{a2}", rx222_cur .local pmc match .lex "$/", match - length rx220_eos, rx220_tgt - gt rx220_pos, rx220_eos, rx220_done - set rx220_off, 0 - lt rx220_pos, 2, rx220_start - sub rx220_off, rx220_pos, 1 - substr rx220_tgt, rx220_tgt, rx220_off - rx220_start: + length rx222_eos, rx222_tgt + gt rx222_pos, rx222_eos, rx222_done + set rx222_off, 0 + lt rx222_pos, 2, rx222_start + sub rx222_off, rx222_pos, 1 + substr rx222_tgt, rx222_tgt, rx222_off + rx222_start: $I10 = self.'from'() - ne $I10, -1, rxscan224_done - goto rxscan224_scan - rxscan224_loop: - ($P10) = rx220_cur."from"() + ne $I10, -1, rxscan226_done + goto rxscan226_scan + rxscan226_loop: + ($P10) = rx222_cur."from"() inc $P10 - set rx220_pos, $P10 - ge rx220_pos, rx220_eos, rxscan224_done - rxscan224_scan: - set_addr $I10, rxscan224_loop - rx220_cur."!mark_push"(0, rx220_pos, $I10) - rxscan224_done: -.annotate 'line', 138 - # rx subrule "finishpad" subtype=method negate= - rx220_cur."!cursor_pos"(rx220_pos) - $P10 = rx220_cur."finishpad"() - unless $P10, rx220_fail - rx220_pos = $P10."pos"() + set rx222_pos, $P10 + ge rx222_pos, rx222_eos, rxscan226_done + rxscan226_scan: + set_addr $I10, rxscan226_loop + rx222_cur."!mark_push"(0, rx222_pos, $I10) + rxscan226_done: .annotate 'line', 139 + # rx subrule "finishpad" subtype=method negate= + rx222_cur."!cursor_pos"(rx222_pos) + $P10 = rx222_cur."finishpad"() + unless $P10, rx222_fail + rx222_pos = $P10."pos"() +.annotate 'line', 140 # rx literal "{" - add $I11, rx220_pos, 1 - gt $I11, rx220_eos, rx220_fail - sub $I11, rx220_pos, rx220_off - substr $S10, rx220_tgt, $I11, 1 - ne $S10, "{", rx220_fail - add rx220_pos, 1 + add $I11, rx222_pos, 1 + gt $I11, rx222_eos, rx222_fail + sub $I11, rx222_pos, rx222_off + substr $S10, rx222_tgt, $I11, 1 + ne $S10, "{", rx222_fail + add rx222_pos, 1 # rx subrule "statementlist" subtype=capture negate= - rx220_cur."!cursor_pos"(rx220_pos) - $P10 = rx220_cur."statementlist"() - unless $P10, rx220_fail - rx220_cur."!mark_push"(0, -1, 0, $P10) + rx222_cur."!cursor_pos"(rx222_pos) + $P10 = rx222_cur."statementlist"() + unless $P10, rx222_fail + rx222_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("statementlist") - rx220_pos = $P10."pos"() - alt225_0: - set_addr $I10, alt225_1 - rx220_cur."!mark_push"(0, rx220_pos, $I10) + rx222_pos = $P10."pos"() + alt227_0: + set_addr $I10, alt227_1 + rx222_cur."!mark_push"(0, rx222_pos, $I10) # rx literal "}" - add $I11, rx220_pos, 1 - gt $I11, rx220_eos, rx220_fail - sub $I11, rx220_pos, rx220_off - substr $S10, rx220_tgt, $I11, 1 - ne $S10, "}", rx220_fail - add rx220_pos, 1 - goto alt225_end - alt225_1: + add $I11, rx222_pos, 1 + gt $I11, rx222_eos, rx222_fail + sub $I11, rx222_pos, rx222_off + substr $S10, rx222_tgt, $I11, 1 + ne $S10, "}", rx222_fail + add rx222_pos, 1 + goto alt227_end + alt227_1: # rx subrule "FAILGOAL" subtype=method negate= - rx220_cur."!cursor_pos"(rx220_pos) - $P10 = rx220_cur."FAILGOAL"("'}'") - unless $P10, rx220_fail - rx220_pos = $P10."pos"() - alt225_end: -.annotate 'line', 140 + rx222_cur."!cursor_pos"(rx222_pos) + $P10 = rx222_cur."FAILGOAL"("'}'") + unless $P10, rx222_fail + rx222_pos = $P10."pos"() + alt227_end: +.annotate 'line', 141 # rx subrule "ENDSTMT" subtype=zerowidth negate= - rx220_cur."!cursor_pos"(rx220_pos) - $P10 = rx220_cur."ENDSTMT"() - unless $P10, rx220_fail -.annotate 'line', 137 + rx222_cur."!cursor_pos"(rx222_pos) + $P10 = rx222_cur."ENDSTMT"() + unless $P10, rx222_fail +.annotate 'line', 138 # rx pass - rx220_cur."!cursor_pass"(rx220_pos, "blockoid") - rx220_cur."!cursor_debug"("PASS ", "blockoid", " at pos=", rx220_pos) - .return (rx220_cur) - rx220_fail: -.annotate 'line', 4 - (rx220_rep, rx220_pos, $I10, $P10) = rx220_cur."!mark_fail"(0) - lt rx220_pos, -1, rx220_done - eq rx220_pos, -1, rx220_fail + rx222_cur."!cursor_pass"(rx222_pos, "blockoid") + rx222_cur."!cursor_debug"("PASS ", "blockoid", " at pos=", rx222_pos) + .return (rx222_cur) + rx222_fail: +.annotate 'line', 4 + (rx222_rep, rx222_pos, $I10, $P10) = rx222_cur."!mark_fail"(0) + lt rx222_pos, -1, rx222_done + eq rx222_pos, -1, rx222_fail jump $I10 - rx220_done: - rx220_cur."!cursor_fail"() - rx220_cur."!cursor_debug"("FAIL ", "blockoid") - .return (rx220_cur) + rx222_done: + rx222_cur."!cursor_fail"() + rx222_cur."!cursor_debug"("FAIL ", "blockoid") + .return (rx222_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__blockoid" :subid("47_1275511697.61926") :method +.sub "!PREFIX__blockoid" :subid("47_1275600007.84296") :method .annotate 'line', 4 - $P222 = self."!PREFIX__!subrule"("", "") - new $P223, "ResizablePMCArray" - push $P223, $P222 - .return ($P223) + $P224 = self."!PREFIX__!subrule"("", "") + new $P225, "ResizablePMCArray" + push $P225, $P224 + .return ($P225) .end .namespace ["NQP";"Grammar"] -.sub "newpad" :subid("48_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "newpad" :subid("48_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx228_tgt - .local int rx228_pos - .local int rx228_off - .local int rx228_eos - .local int rx228_rep - .local pmc rx228_cur - (rx228_cur, rx228_pos, rx228_tgt) = self."!cursor_start"() - rx228_cur."!cursor_debug"("START ", "newpad") - .lex unicode:"$\x{a2}", rx228_cur + .local string rx230_tgt + .local int rx230_pos + .local int rx230_off + .local int rx230_eos + .local int rx230_rep + .local pmc rx230_cur + (rx230_cur, rx230_pos, rx230_tgt) = self."!cursor_start"() + rx230_cur."!cursor_debug"("START ", "newpad") + .lex unicode:"$\x{a2}", rx230_cur .local pmc match .lex "$/", match - length rx228_eos, rx228_tgt - gt rx228_pos, rx228_eos, rx228_done - set rx228_off, 0 - lt rx228_pos, 2, rx228_start - sub rx228_off, rx228_pos, 1 - substr rx228_tgt, rx228_tgt, rx228_off - rx228_start: + length rx230_eos, rx230_tgt + gt rx230_pos, rx230_eos, rx230_done + set rx230_off, 0 + lt rx230_pos, 2, rx230_start + sub rx230_off, rx230_pos, 1 + substr rx230_tgt, rx230_tgt, rx230_off + rx230_start: $I10 = self.'from'() - ne $I10, -1, rxscan231_done - goto rxscan231_scan - rxscan231_loop: - ($P10) = rx228_cur."from"() + ne $I10, -1, rxscan233_done + goto rxscan233_scan + rxscan233_loop: + ($P10) = rx230_cur."from"() inc $P10 - set rx228_pos, $P10 - ge rx228_pos, rx228_eos, rxscan231_done - rxscan231_scan: - set_addr $I10, rxscan231_loop - rx228_cur."!mark_push"(0, rx228_pos, $I10) - rxscan231_done: -.annotate 'line', 143 + set rx230_pos, $P10 + ge rx230_pos, rx230_eos, rxscan233_done + rxscan233_scan: + set_addr $I10, rxscan233_loop + rx230_cur."!mark_push"(0, rx230_pos, $I10) + rxscan233_done: +.annotate 'line', 144 # rx pass - rx228_cur."!cursor_pass"(rx228_pos, "newpad") - rx228_cur."!cursor_debug"("PASS ", "newpad", " at pos=", rx228_pos) - .return (rx228_cur) - rx228_fail: -.annotate 'line', 4 - (rx228_rep, rx228_pos, $I10, $P10) = rx228_cur."!mark_fail"(0) - lt rx228_pos, -1, rx228_done - eq rx228_pos, -1, rx228_fail + rx230_cur."!cursor_pass"(rx230_pos, "newpad") + rx230_cur."!cursor_debug"("PASS ", "newpad", " at pos=", rx230_pos) + .return (rx230_cur) + rx230_fail: +.annotate 'line', 4 + (rx230_rep, rx230_pos, $I10, $P10) = rx230_cur."!mark_fail"(0) + lt rx230_pos, -1, rx230_done + eq rx230_pos, -1, rx230_fail jump $I10 - rx228_done: - rx228_cur."!cursor_fail"() - rx228_cur."!cursor_debug"("FAIL ", "newpad") - .return (rx228_cur) + rx230_done: + rx230_cur."!cursor_fail"() + rx230_cur."!cursor_debug"("FAIL ", "newpad") + .return (rx230_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__newpad" :subid("49_1275511697.61926") :method +.sub "!PREFIX__newpad" :subid("49_1275600007.84296") :method .annotate 'line', 4 - new $P230, "ResizablePMCArray" - push $P230, "" - .return ($P230) + new $P232, "ResizablePMCArray" + push $P232, "" + .return ($P232) .end .namespace ["NQP";"Grammar"] -.sub "outerctx" :subid("50_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "outerctx" :subid("50_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx233_tgt - .local int rx233_pos - .local int rx233_off - .local int rx233_eos - .local int rx233_rep - .local pmc rx233_cur - (rx233_cur, rx233_pos, rx233_tgt) = self."!cursor_start"() - rx233_cur."!cursor_debug"("START ", "outerctx") - .lex unicode:"$\x{a2}", rx233_cur + .local string rx235_tgt + .local int rx235_pos + .local int rx235_off + .local int rx235_eos + .local int rx235_rep + .local pmc rx235_cur + (rx235_cur, rx235_pos, rx235_tgt) = self."!cursor_start"() + rx235_cur."!cursor_debug"("START ", "outerctx") + .lex unicode:"$\x{a2}", rx235_cur .local pmc match .lex "$/", match - length rx233_eos, rx233_tgt - gt rx233_pos, rx233_eos, rx233_done - set rx233_off, 0 - lt rx233_pos, 2, rx233_start - sub rx233_off, rx233_pos, 1 - substr rx233_tgt, rx233_tgt, rx233_off - rx233_start: + length rx235_eos, rx235_tgt + gt rx235_pos, rx235_eos, rx235_done + set rx235_off, 0 + lt rx235_pos, 2, rx235_start + sub rx235_off, rx235_pos, 1 + substr rx235_tgt, rx235_tgt, rx235_off + rx235_start: $I10 = self.'from'() - ne $I10, -1, rxscan236_done - goto rxscan236_scan - rxscan236_loop: - ($P10) = rx233_cur."from"() + ne $I10, -1, rxscan238_done + goto rxscan238_scan + rxscan238_loop: + ($P10) = rx235_cur."from"() inc $P10 - set rx233_pos, $P10 - ge rx233_pos, rx233_eos, rxscan236_done - rxscan236_scan: - set_addr $I10, rxscan236_loop - rx233_cur."!mark_push"(0, rx233_pos, $I10) - rxscan236_done: -.annotate 'line', 144 + set rx235_pos, $P10 + ge rx235_pos, rx235_eos, rxscan238_done + rxscan238_scan: + set_addr $I10, rxscan238_loop + rx235_cur."!mark_push"(0, rx235_pos, $I10) + rxscan238_done: +.annotate 'line', 145 # rx pass - rx233_cur."!cursor_pass"(rx233_pos, "outerctx") - rx233_cur."!cursor_debug"("PASS ", "outerctx", " at pos=", rx233_pos) - .return (rx233_cur) - rx233_fail: -.annotate 'line', 4 - (rx233_rep, rx233_pos, $I10, $P10) = rx233_cur."!mark_fail"(0) - lt rx233_pos, -1, rx233_done - eq rx233_pos, -1, rx233_fail + rx235_cur."!cursor_pass"(rx235_pos, "outerctx") + rx235_cur."!cursor_debug"("PASS ", "outerctx", " at pos=", rx235_pos) + .return (rx235_cur) + rx235_fail: +.annotate 'line', 4 + (rx235_rep, rx235_pos, $I10, $P10) = rx235_cur."!mark_fail"(0) + lt rx235_pos, -1, rx235_done + eq rx235_pos, -1, rx235_fail jump $I10 - rx233_done: - rx233_cur."!cursor_fail"() - rx233_cur."!cursor_debug"("FAIL ", "outerctx") - .return (rx233_cur) + rx235_done: + rx235_cur."!cursor_fail"() + rx235_cur."!cursor_debug"("FAIL ", "outerctx") + .return (rx235_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__outerctx" :subid("51_1275511697.61926") :method +.sub "!PREFIX__outerctx" :subid("51_1275600007.84296") :method .annotate 'line', 4 - new $P235, "ResizablePMCArray" - push $P235, "" - .return ($P235) + new $P237, "ResizablePMCArray" + push $P237, "" + .return ($P237) .end .namespace ["NQP";"Grammar"] -.sub "finishpad" :subid("52_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "finishpad" :subid("52_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx238_tgt - .local int rx238_pos - .local int rx238_off - .local int rx238_eos - .local int rx238_rep - .local pmc rx238_cur - (rx238_cur, rx238_pos, rx238_tgt) = self."!cursor_start"() - rx238_cur."!cursor_debug"("START ", "finishpad") - .lex unicode:"$\x{a2}", rx238_cur + .local string rx240_tgt + .local int rx240_pos + .local int rx240_off + .local int rx240_eos + .local int rx240_rep + .local pmc rx240_cur + (rx240_cur, rx240_pos, rx240_tgt) = self."!cursor_start"() + rx240_cur."!cursor_debug"("START ", "finishpad") + .lex unicode:"$\x{a2}", rx240_cur .local pmc match .lex "$/", match - length rx238_eos, rx238_tgt - gt rx238_pos, rx238_eos, rx238_done - set rx238_off, 0 - lt rx238_pos, 2, rx238_start - sub rx238_off, rx238_pos, 1 - substr rx238_tgt, rx238_tgt, rx238_off - rx238_start: + length rx240_eos, rx240_tgt + gt rx240_pos, rx240_eos, rx240_done + set rx240_off, 0 + lt rx240_pos, 2, rx240_start + sub rx240_off, rx240_pos, 1 + substr rx240_tgt, rx240_tgt, rx240_off + rx240_start: $I10 = self.'from'() - ne $I10, -1, rxscan241_done - goto rxscan241_scan - rxscan241_loop: - ($P10) = rx238_cur."from"() + ne $I10, -1, rxscan243_done + goto rxscan243_scan + rxscan243_loop: + ($P10) = rx240_cur."from"() inc $P10 - set rx238_pos, $P10 - ge rx238_pos, rx238_eos, rxscan241_done - rxscan241_scan: - set_addr $I10, rxscan241_loop - rx238_cur."!mark_push"(0, rx238_pos, $I10) - rxscan241_done: -.annotate 'line', 145 + set rx240_pos, $P10 + ge rx240_pos, rx240_eos, rxscan243_done + rxscan243_scan: + set_addr $I10, rxscan243_loop + rx240_cur."!mark_push"(0, rx240_pos, $I10) + rxscan243_done: +.annotate 'line', 146 # rx pass - rx238_cur."!cursor_pass"(rx238_pos, "finishpad") - rx238_cur."!cursor_debug"("PASS ", "finishpad", " at pos=", rx238_pos) - .return (rx238_cur) - rx238_fail: -.annotate 'line', 4 - (rx238_rep, rx238_pos, $I10, $P10) = rx238_cur."!mark_fail"(0) - lt rx238_pos, -1, rx238_done - eq rx238_pos, -1, rx238_fail + rx240_cur."!cursor_pass"(rx240_pos, "finishpad") + rx240_cur."!cursor_debug"("PASS ", "finishpad", " at pos=", rx240_pos) + .return (rx240_cur) + rx240_fail: +.annotate 'line', 4 + (rx240_rep, rx240_pos, $I10, $P10) = rx240_cur."!mark_fail"(0) + lt rx240_pos, -1, rx240_done + eq rx240_pos, -1, rx240_fail jump $I10 - rx238_done: - rx238_cur."!cursor_fail"() - rx238_cur."!cursor_debug"("FAIL ", "finishpad") - .return (rx238_cur) + rx240_done: + rx240_cur."!cursor_fail"() + rx240_cur."!cursor_debug"("FAIL ", "finishpad") + .return (rx240_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__finishpad" :subid("53_1275511697.61926") :method +.sub "!PREFIX__finishpad" :subid("53_1275600007.84296") :method .annotate 'line', 4 - new $P240, "ResizablePMCArray" - push $P240, "" - .return ($P240) + new $P242, "ResizablePMCArray" + push $P242, "" + .return ($P242) .end .namespace ["NQP";"Grammar"] -.sub "terminator" :subid("54_1275511697.61926") :method -.annotate 'line', 147 - $P243 = self."!protoregex"("terminator") - .return ($P243) +.sub "terminator" :subid("54_1275600007.84296") :method +.annotate 'line', 148 + $P245 = self."!protoregex"("terminator") + .return ($P245) .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__terminator" :subid("55_1275511697.61926") :method -.annotate 'line', 147 - $P245 = self."!PREFIX__!protoregex"("terminator") - .return ($P245) +.sub "!PREFIX__terminator" :subid("55_1275600007.84296") :method +.annotate 'line', 148 + $P247 = self."!PREFIX__!protoregex"("terminator") + .return ($P247) .end .namespace ["NQP";"Grammar"] -.sub "terminator:sym<;>" :subid("56_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "terminator:sym<;>" :subid("56_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx247_tgt - .local int rx247_pos - .local int rx247_off - .local int rx247_eos - .local int rx247_rep - .local pmc rx247_cur - (rx247_cur, rx247_pos, rx247_tgt) = self."!cursor_start"() - rx247_cur."!cursor_debug"("START ", "terminator:sym<;>") - .lex unicode:"$\x{a2}", rx247_cur + .local string rx249_tgt + .local int rx249_pos + .local int rx249_off + .local int rx249_eos + .local int rx249_rep + .local pmc rx249_cur + (rx249_cur, rx249_pos, rx249_tgt) = self."!cursor_start"() + rx249_cur."!cursor_debug"("START ", "terminator:sym<;>") + .lex unicode:"$\x{a2}", rx249_cur .local pmc match .lex "$/", match - length rx247_eos, rx247_tgt - gt rx247_pos, rx247_eos, rx247_done - set rx247_off, 0 - lt rx247_pos, 2, rx247_start - sub rx247_off, rx247_pos, 1 - substr rx247_tgt, rx247_tgt, rx247_off - rx247_start: + length rx249_eos, rx249_tgt + gt rx249_pos, rx249_eos, rx249_done + set rx249_off, 0 + lt rx249_pos, 2, rx249_start + sub rx249_off, rx249_pos, 1 + substr rx249_tgt, rx249_tgt, rx249_off + rx249_start: $I10 = self.'from'() - ne $I10, -1, rxscan250_done - goto rxscan250_scan - rxscan250_loop: - ($P10) = rx247_cur."from"() + ne $I10, -1, rxscan252_done + goto rxscan252_scan + rxscan252_loop: + ($P10) = rx249_cur."from"() inc $P10 - set rx247_pos, $P10 - ge rx247_pos, rx247_eos, rxscan250_done - rxscan250_scan: - set_addr $I10, rxscan250_loop - rx247_cur."!mark_push"(0, rx247_pos, $I10) - rxscan250_done: -.annotate 'line', 149 + set rx249_pos, $P10 + ge rx249_pos, rx249_eos, rxscan252_done + rxscan252_scan: + set_addr $I10, rxscan252_loop + rx249_cur."!mark_push"(0, rx249_pos, $I10) + rxscan252_done: +.annotate 'line', 150 # rx enumcharlist negate=0 zerowidth - ge rx247_pos, rx247_eos, rx247_fail - sub $I10, rx247_pos, rx247_off - substr $S10, rx247_tgt, $I10, 1 + ge rx249_pos, rx249_eos, rx249_fail + sub $I10, rx249_pos, rx249_off + substr $S10, rx249_tgt, $I10, 1 index $I11, ";", $S10 - lt $I11, 0, rx247_fail + lt $I11, 0, rx249_fail # rx pass - rx247_cur."!cursor_pass"(rx247_pos, "terminator:sym<;>") - rx247_cur."!cursor_debug"("PASS ", "terminator:sym<;>", " at pos=", rx247_pos) - .return (rx247_cur) - rx247_fail: -.annotate 'line', 4 - (rx247_rep, rx247_pos, $I10, $P10) = rx247_cur."!mark_fail"(0) - lt rx247_pos, -1, rx247_done - eq rx247_pos, -1, rx247_fail + rx249_cur."!cursor_pass"(rx249_pos, "terminator:sym<;>") + rx249_cur."!cursor_debug"("PASS ", "terminator:sym<;>", " at pos=", rx249_pos) + .return (rx249_cur) + rx249_fail: +.annotate 'line', 4 + (rx249_rep, rx249_pos, $I10, $P10) = rx249_cur."!mark_fail"(0) + lt rx249_pos, -1, rx249_done + eq rx249_pos, -1, rx249_fail jump $I10 - rx247_done: - rx247_cur."!cursor_fail"() - rx247_cur."!cursor_debug"("FAIL ", "terminator:sym<;>") - .return (rx247_cur) + rx249_done: + rx249_cur."!cursor_fail"() + rx249_cur."!cursor_debug"("FAIL ", "terminator:sym<;>") + .return (rx249_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__terminator:sym<;>" :subid("57_1275511697.61926") :method +.sub "!PREFIX__terminator:sym<;>" :subid("57_1275600007.84296") :method .annotate 'line', 4 - new $P249, "ResizablePMCArray" - push $P249, ";" - .return ($P249) + new $P251, "ResizablePMCArray" + push $P251, ";" + .return ($P251) .end .namespace ["NQP";"Grammar"] -.sub "terminator:sym<}>" :subid("58_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "terminator:sym<}>" :subid("58_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx252_tgt - .local int rx252_pos - .local int rx252_off - .local int rx252_eos - .local int rx252_rep - .local pmc rx252_cur - (rx252_cur, rx252_pos, rx252_tgt) = self."!cursor_start"() - rx252_cur."!cursor_debug"("START ", "terminator:sym<}>") - .lex unicode:"$\x{a2}", rx252_cur + .local string rx254_tgt + .local int rx254_pos + .local int rx254_off + .local int rx254_eos + .local int rx254_rep + .local pmc rx254_cur + (rx254_cur, rx254_pos, rx254_tgt) = self."!cursor_start"() + rx254_cur."!cursor_debug"("START ", "terminator:sym<}>") + .lex unicode:"$\x{a2}", rx254_cur .local pmc match .lex "$/", match - length rx252_eos, rx252_tgt - gt rx252_pos, rx252_eos, rx252_done - set rx252_off, 0 - lt rx252_pos, 2, rx252_start - sub rx252_off, rx252_pos, 1 - substr rx252_tgt, rx252_tgt, rx252_off - rx252_start: + length rx254_eos, rx254_tgt + gt rx254_pos, rx254_eos, rx254_done + set rx254_off, 0 + lt rx254_pos, 2, rx254_start + sub rx254_off, rx254_pos, 1 + substr rx254_tgt, rx254_tgt, rx254_off + rx254_start: $I10 = self.'from'() - ne $I10, -1, rxscan255_done - goto rxscan255_scan - rxscan255_loop: - ($P10) = rx252_cur."from"() + ne $I10, -1, rxscan257_done + goto rxscan257_scan + rxscan257_loop: + ($P10) = rx254_cur."from"() inc $P10 - set rx252_pos, $P10 - ge rx252_pos, rx252_eos, rxscan255_done - rxscan255_scan: - set_addr $I10, rxscan255_loop - rx252_cur."!mark_push"(0, rx252_pos, $I10) - rxscan255_done: -.annotate 'line', 150 + set rx254_pos, $P10 + ge rx254_pos, rx254_eos, rxscan257_done + rxscan257_scan: + set_addr $I10, rxscan257_loop + rx254_cur."!mark_push"(0, rx254_pos, $I10) + rxscan257_done: +.annotate 'line', 151 # rx enumcharlist negate=0 zerowidth - ge rx252_pos, rx252_eos, rx252_fail - sub $I10, rx252_pos, rx252_off - substr $S10, rx252_tgt, $I10, 1 + ge rx254_pos, rx254_eos, rx254_fail + sub $I10, rx254_pos, rx254_off + substr $S10, rx254_tgt, $I10, 1 index $I11, "}", $S10 - lt $I11, 0, rx252_fail + lt $I11, 0, rx254_fail # rx pass - rx252_cur."!cursor_pass"(rx252_pos, "terminator:sym<}>") - rx252_cur."!cursor_debug"("PASS ", "terminator:sym<}>", " at pos=", rx252_pos) - .return (rx252_cur) - rx252_fail: -.annotate 'line', 4 - (rx252_rep, rx252_pos, $I10, $P10) = rx252_cur."!mark_fail"(0) - lt rx252_pos, -1, rx252_done - eq rx252_pos, -1, rx252_fail + rx254_cur."!cursor_pass"(rx254_pos, "terminator:sym<}>") + rx254_cur."!cursor_debug"("PASS ", "terminator:sym<}>", " at pos=", rx254_pos) + .return (rx254_cur) + rx254_fail: +.annotate 'line', 4 + (rx254_rep, rx254_pos, $I10, $P10) = rx254_cur."!mark_fail"(0) + lt rx254_pos, -1, rx254_done + eq rx254_pos, -1, rx254_fail jump $I10 - rx252_done: - rx252_cur."!cursor_fail"() - rx252_cur."!cursor_debug"("FAIL ", "terminator:sym<}>") - .return (rx252_cur) + rx254_done: + rx254_cur."!cursor_fail"() + rx254_cur."!cursor_debug"("FAIL ", "terminator:sym<}>") + .return (rx254_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__terminator:sym<}>" :subid("59_1275511697.61926") :method +.sub "!PREFIX__terminator:sym<}>" :subid("59_1275600007.84296") :method .annotate 'line', 4 - new $P254, "ResizablePMCArray" - push $P254, "}" - .return ($P254) + new $P256, "ResizablePMCArray" + push $P256, "}" + .return ($P256) .end .namespace ["NQP";"Grammar"] -.sub "statement_control" :subid("60_1275511697.61926") :method -.annotate 'line', 154 - $P257 = self."!protoregex"("statement_control") - .return ($P257) +.sub "statement_control" :subid("60_1275600007.84296") :method +.annotate 'line', 155 + $P259 = self."!protoregex"("statement_control") + .return ($P259) .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_control" :subid("61_1275511697.61926") :method -.annotate 'line', 154 - $P259 = self."!PREFIX__!protoregex"("statement_control") - .return ($P259) +.sub "!PREFIX__statement_control" :subid("61_1275600007.84296") :method +.annotate 'line', 155 + $P261 = self."!PREFIX__!protoregex"("statement_control") + .return ($P261) .end .namespace ["NQP";"Grammar"] -.sub "statement_control:sym" :subid("62_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement_control:sym" :subid("62_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx261_tgt - .local int rx261_pos - .local int rx261_off - .local int rx261_eos - .local int rx261_rep - .local pmc rx261_cur - (rx261_cur, rx261_pos, rx261_tgt) = self."!cursor_start"() - rx261_cur."!cursor_debug"("START ", "statement_control:sym") - rx261_cur."!cursor_caparray"("xblock", "else") - .lex unicode:"$\x{a2}", rx261_cur + .local string rx263_tgt + .local int rx263_pos + .local int rx263_off + .local int rx263_eos + .local int rx263_rep + .local pmc rx263_cur + (rx263_cur, rx263_pos, rx263_tgt) = self."!cursor_start"() + rx263_cur."!cursor_debug"("START ", "statement_control:sym") + rx263_cur."!cursor_caparray"("else", "xblock") + .lex unicode:"$\x{a2}", rx263_cur .local pmc match .lex "$/", match - length rx261_eos, rx261_tgt - gt rx261_pos, rx261_eos, rx261_done - set rx261_off, 0 - lt rx261_pos, 2, rx261_start - sub rx261_off, rx261_pos, 1 - substr rx261_tgt, rx261_tgt, rx261_off - rx261_start: + length rx263_eos, rx263_tgt + gt rx263_pos, rx263_eos, rx263_done + set rx263_off, 0 + lt rx263_pos, 2, rx263_start + sub rx263_off, rx263_pos, 1 + substr rx263_tgt, rx263_tgt, rx263_off + rx263_start: $I10 = self.'from'() - ne $I10, -1, rxscan264_done - goto rxscan264_scan - rxscan264_loop: - ($P10) = rx261_cur."from"() + ne $I10, -1, rxscan266_done + goto rxscan266_scan + rxscan266_loop: + ($P10) = rx263_cur."from"() inc $P10 - set rx261_pos, $P10 - ge rx261_pos, rx261_eos, rxscan264_done - rxscan264_scan: - set_addr $I10, rxscan264_loop - rx261_cur."!mark_push"(0, rx261_pos, $I10) - rxscan264_done: -.annotate 'line', 157 + set rx263_pos, $P10 + ge rx263_pos, rx263_eos, rxscan266_done + rxscan266_scan: + set_addr $I10, rxscan266_loop + rx263_cur."!mark_push"(0, rx263_pos, $I10) + rxscan266_done: +.annotate 'line', 158 # rx subcapture "sym" - set_addr $I10, rxcap_265_fail - rx261_cur."!mark_push"(0, rx261_pos, $I10) + set_addr $I10, rxcap_267_fail + rx263_cur."!mark_push"(0, rx263_pos, $I10) # rx literal "if" - add $I11, rx261_pos, 2 - gt $I11, rx261_eos, rx261_fail - sub $I11, rx261_pos, rx261_off - substr $S10, rx261_tgt, $I11, 2 - ne $S10, "if", rx261_fail - add rx261_pos, 2 - set_addr $I10, rxcap_265_fail - ($I12, $I11) = rx261_cur."!mark_peek"($I10) - rx261_cur."!cursor_pos"($I11) - ($P10) = rx261_cur."!cursor_start"() - $P10."!cursor_pass"(rx261_pos, "") - rx261_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx263_pos, 2 + gt $I11, rx263_eos, rx263_fail + sub $I11, rx263_pos, rx263_off + substr $S10, rx263_tgt, $I11, 2 + ne $S10, "if", rx263_fail + add rx263_pos, 2 + set_addr $I10, rxcap_267_fail + ($I12, $I11) = rx263_cur."!mark_peek"($I10) + rx263_cur."!cursor_pos"($I11) + ($P10) = rx263_cur."!cursor_start"() + $P10."!cursor_pass"(rx263_pos, "") + rx263_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_265_done - rxcap_265_fail: - goto rx261_fail - rxcap_265_done: + goto rxcap_267_done + rxcap_267_fail: + goto rx263_fail + rxcap_267_done: # rx charclass s - ge rx261_pos, rx261_eos, rx261_fail - sub $I10, rx261_pos, rx261_off - is_cclass $I11, 32, rx261_tgt, $I10 - unless $I11, rx261_fail - inc rx261_pos + ge rx263_pos, rx263_eos, rx263_fail + sub $I10, rx263_pos, rx263_off + is_cclass $I11, 32, rx263_tgt, $I10 + unless $I11, rx263_fail + inc rx263_pos # rx subrule "ws" subtype=method negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."ws"() - unless $P10, rx261_fail - rx261_pos = $P10."pos"() -.annotate 'line', 158 + rx263_cur."!cursor_pos"(rx263_pos) + $P10 = rx263_cur."ws"() + unless $P10, rx263_fail + rx263_pos = $P10."pos"() +.annotate 'line', 159 # rx subrule "xblock" subtype=capture negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."xblock"() - unless $P10, rx261_fail - rx261_cur."!mark_push"(0, -1, 0, $P10) + rx263_cur."!cursor_pos"(rx263_pos) + $P10 = rx263_cur."xblock"() + unless $P10, rx263_fail + rx263_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("xblock") - rx261_pos = $P10."pos"() + rx263_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."ws"() - unless $P10, rx261_fail - rx261_pos = $P10."pos"() -.annotate 'line', 159 - # rx rxquantr268 ** 0..* - set_addr $I272, rxquantr268_done - rx261_cur."!mark_push"(0, rx261_pos, $I272) - rxquantr268_loop: + rx263_cur."!cursor_pos"(rx263_pos) + $P10 = rx263_cur."ws"() + unless $P10, rx263_fail + rx263_pos = $P10."pos"() +.annotate 'line', 160 + # rx rxquantr270 ** 0..* + set_addr $I274, rxquantr270_done + rx263_cur."!mark_push"(0, rx263_pos, $I274) + rxquantr270_loop: # rx subrule "ws" subtype=method negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."ws"() - unless $P10, rx261_fail - rx261_pos = $P10."pos"() + rx263_cur."!cursor_pos"(rx263_pos) + $P10 = rx263_cur."ws"() + unless $P10, rx263_fail + rx263_pos = $P10."pos"() # rx literal "elsif" - add $I11, rx261_pos, 5 - gt $I11, rx261_eos, rx261_fail - sub $I11, rx261_pos, rx261_off - substr $S10, rx261_tgt, $I11, 5 - ne $S10, "elsif", rx261_fail - add rx261_pos, 5 + add $I11, rx263_pos, 5 + gt $I11, rx263_eos, rx263_fail + sub $I11, rx263_pos, rx263_off + substr $S10, rx263_tgt, $I11, 5 + ne $S10, "elsif", rx263_fail + add rx263_pos, 5 # rx charclass s - ge rx261_pos, rx261_eos, rx261_fail - sub $I10, rx261_pos, rx261_off - is_cclass $I11, 32, rx261_tgt, $I10 - unless $I11, rx261_fail - inc rx261_pos + ge rx263_pos, rx263_eos, rx263_fail + sub $I10, rx263_pos, rx263_off + is_cclass $I11, 32, rx263_tgt, $I10 + unless $I11, rx263_fail + inc rx263_pos # rx subrule "ws" subtype=method negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."ws"() - unless $P10, rx261_fail - rx261_pos = $P10."pos"() + rx263_cur."!cursor_pos"(rx263_pos) + $P10 = rx263_cur."ws"() + unless $P10, rx263_fail + rx263_pos = $P10."pos"() # rx subrule "xblock" subtype=capture negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."xblock"() - unless $P10, rx261_fail - rx261_cur."!mark_push"(0, -1, 0, $P10) + rx263_cur."!cursor_pos"(rx263_pos) + $P10 = rx263_cur."xblock"() + unless $P10, rx263_fail + rx263_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("xblock") - rx261_pos = $P10."pos"() + rx263_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."ws"() - unless $P10, rx261_fail - rx261_pos = $P10."pos"() - (rx261_rep) = rx261_cur."!mark_commit"($I272) - rx261_cur."!mark_push"(rx261_rep, rx261_pos, $I272) - goto rxquantr268_loop - rxquantr268_done: + rx263_cur."!cursor_pos"(rx263_pos) + $P10 = rx263_cur."ws"() + unless $P10, rx263_fail + rx263_pos = $P10."pos"() + (rx263_rep) = rx263_cur."!mark_commit"($I274) + rx263_cur."!mark_push"(rx263_rep, rx263_pos, $I274) + goto rxquantr270_loop + rxquantr270_done: # rx subrule "ws" subtype=method negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."ws"() - unless $P10, rx261_fail - rx261_pos = $P10."pos"() -.annotate 'line', 160 - # rx rxquantr274 ** 0..1 - set_addr $I278, rxquantr274_done - rx261_cur."!mark_push"(0, rx261_pos, $I278) - rxquantr274_loop: + rx263_cur."!cursor_pos"(rx263_pos) + $P10 = rx263_cur."ws"() + unless $P10, rx263_fail + rx263_pos = $P10."pos"() +.annotate 'line', 161 + # rx rxquantr276 ** 0..1 + set_addr $I280, rxquantr276_done + rx263_cur."!mark_push"(0, rx263_pos, $I280) + rxquantr276_loop: # rx subrule "ws" subtype=method negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."ws"() - unless $P10, rx261_fail - rx261_pos = $P10."pos"() + rx263_cur."!cursor_pos"(rx263_pos) + $P10 = rx263_cur."ws"() + unless $P10, rx263_fail + rx263_pos = $P10."pos"() # rx literal "else" - add $I11, rx261_pos, 4 - gt $I11, rx261_eos, rx261_fail - sub $I11, rx261_pos, rx261_off - substr $S10, rx261_tgt, $I11, 4 - ne $S10, "else", rx261_fail - add rx261_pos, 4 + add $I11, rx263_pos, 4 + gt $I11, rx263_eos, rx263_fail + sub $I11, rx263_pos, rx263_off + substr $S10, rx263_tgt, $I11, 4 + ne $S10, "else", rx263_fail + add rx263_pos, 4 # rx charclass s - ge rx261_pos, rx261_eos, rx261_fail - sub $I10, rx261_pos, rx261_off - is_cclass $I11, 32, rx261_tgt, $I10 - unless $I11, rx261_fail - inc rx261_pos + ge rx263_pos, rx263_eos, rx263_fail + sub $I10, rx263_pos, rx263_off + is_cclass $I11, 32, rx263_tgt, $I10 + unless $I11, rx263_fail + inc rx263_pos # rx subrule "ws" subtype=method negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."ws"() - unless $P10, rx261_fail - rx261_pos = $P10."pos"() + rx263_cur."!cursor_pos"(rx263_pos) + $P10 = rx263_cur."ws"() + unless $P10, rx263_fail + rx263_pos = $P10."pos"() # rx subrule "pblock" subtype=capture negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."pblock"() - unless $P10, rx261_fail - rx261_cur."!mark_push"(0, -1, 0, $P10) + rx263_cur."!cursor_pos"(rx263_pos) + $P10 = rx263_cur."pblock"() + unless $P10, rx263_fail + rx263_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("else") - rx261_pos = $P10."pos"() + rx263_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."ws"() - unless $P10, rx261_fail - rx261_pos = $P10."pos"() - (rx261_rep) = rx261_cur."!mark_commit"($I278) - rxquantr274_done: + rx263_cur."!cursor_pos"(rx263_pos) + $P10 = rx263_cur."ws"() + unless $P10, rx263_fail + rx263_pos = $P10."pos"() + (rx263_rep) = rx263_cur."!mark_commit"($I280) + rxquantr276_done: # rx subrule "ws" subtype=method negate= - rx261_cur."!cursor_pos"(rx261_pos) - $P10 = rx261_cur."ws"() - unless $P10, rx261_fail - rx261_pos = $P10."pos"() -.annotate 'line', 156 + rx263_cur."!cursor_pos"(rx263_pos) + $P10 = rx263_cur."ws"() + unless $P10, rx263_fail + rx263_pos = $P10."pos"() +.annotate 'line', 157 # rx pass - rx261_cur."!cursor_pass"(rx261_pos, "statement_control:sym") - rx261_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx261_pos) - .return (rx261_cur) - rx261_fail: -.annotate 'line', 4 - (rx261_rep, rx261_pos, $I10, $P10) = rx261_cur."!mark_fail"(0) - lt rx261_pos, -1, rx261_done - eq rx261_pos, -1, rx261_fail + rx263_cur."!cursor_pass"(rx263_pos, "statement_control:sym") + rx263_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx263_pos) + .return (rx263_cur) + rx263_fail: +.annotate 'line', 4 + (rx263_rep, rx263_pos, $I10, $P10) = rx263_cur."!mark_fail"(0) + lt rx263_pos, -1, rx263_done + eq rx263_pos, -1, rx263_fail jump $I10 - rx261_done: - rx261_cur."!cursor_fail"() - rx261_cur."!cursor_debug"("FAIL ", "statement_control:sym") - .return (rx261_cur) + rx263_done: + rx263_cur."!cursor_fail"() + rx263_cur."!cursor_debug"("FAIL ", "statement_control:sym") + .return (rx263_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_control:sym" :subid("63_1275511697.61926") :method +.sub "!PREFIX__statement_control:sym" :subid("63_1275600007.84296") :method .annotate 'line', 4 - new $P263, "ResizablePMCArray" - push $P263, "if" - .return ($P263) + new $P265, "ResizablePMCArray" + push $P265, "if" + .return ($P265) .end .namespace ["NQP";"Grammar"] -.sub "statement_control:sym" :subid("64_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement_control:sym" :subid("64_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .const 'Sub' $P291 = "66_1275511697.61926" - capture_lex $P291 - .local string rx281_tgt - .local int rx281_pos - .local int rx281_off - .local int rx281_eos - .local int rx281_rep - .local pmc rx281_cur - (rx281_cur, rx281_pos, rx281_tgt) = self."!cursor_start"() - rx281_cur."!cursor_debug"("START ", "statement_control:sym") - .lex unicode:"$\x{a2}", rx281_cur + .const 'Sub' $P293 = "66_1275600007.84296" + capture_lex $P293 + .local string rx283_tgt + .local int rx283_pos + .local int rx283_off + .local int rx283_eos + .local int rx283_rep + .local pmc rx283_cur + (rx283_cur, rx283_pos, rx283_tgt) = self."!cursor_start"() + rx283_cur."!cursor_debug"("START ", "statement_control:sym") + .lex unicode:"$\x{a2}", rx283_cur .local pmc match .lex "$/", match - length rx281_eos, rx281_tgt - gt rx281_pos, rx281_eos, rx281_done - set rx281_off, 0 - lt rx281_pos, 2, rx281_start - sub rx281_off, rx281_pos, 1 - substr rx281_tgt, rx281_tgt, rx281_off - rx281_start: + length rx283_eos, rx283_tgt + gt rx283_pos, rx283_eos, rx283_done + set rx283_off, 0 + lt rx283_pos, 2, rx283_start + sub rx283_off, rx283_pos, 1 + substr rx283_tgt, rx283_tgt, rx283_off + rx283_start: $I10 = self.'from'() - ne $I10, -1, rxscan284_done - goto rxscan284_scan - rxscan284_loop: - ($P10) = rx281_cur."from"() + ne $I10, -1, rxscan286_done + goto rxscan286_scan + rxscan286_loop: + ($P10) = rx283_cur."from"() inc $P10 - set rx281_pos, $P10 - ge rx281_pos, rx281_eos, rxscan284_done - rxscan284_scan: - set_addr $I10, rxscan284_loop - rx281_cur."!mark_push"(0, rx281_pos, $I10) - rxscan284_done: -.annotate 'line', 164 + set rx283_pos, $P10 + ge rx283_pos, rx283_eos, rxscan286_done + rxscan286_scan: + set_addr $I10, rxscan286_loop + rx283_cur."!mark_push"(0, rx283_pos, $I10) + rxscan286_done: +.annotate 'line', 165 # rx subcapture "sym" - set_addr $I10, rxcap_285_fail - rx281_cur."!mark_push"(0, rx281_pos, $I10) + set_addr $I10, rxcap_287_fail + rx283_cur."!mark_push"(0, rx283_pos, $I10) # rx literal "unless" - add $I11, rx281_pos, 6 - gt $I11, rx281_eos, rx281_fail - sub $I11, rx281_pos, rx281_off - substr $S10, rx281_tgt, $I11, 6 - ne $S10, "unless", rx281_fail - add rx281_pos, 6 - set_addr $I10, rxcap_285_fail - ($I12, $I11) = rx281_cur."!mark_peek"($I10) - rx281_cur."!cursor_pos"($I11) - ($P10) = rx281_cur."!cursor_start"() - $P10."!cursor_pass"(rx281_pos, "") - rx281_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx283_pos, 6 + gt $I11, rx283_eos, rx283_fail + sub $I11, rx283_pos, rx283_off + substr $S10, rx283_tgt, $I11, 6 + ne $S10, "unless", rx283_fail + add rx283_pos, 6 + set_addr $I10, rxcap_287_fail + ($I12, $I11) = rx283_cur."!mark_peek"($I10) + rx283_cur."!cursor_pos"($I11) + ($P10) = rx283_cur."!cursor_start"() + $P10."!cursor_pass"(rx283_pos, "") + rx283_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_285_done - rxcap_285_fail: - goto rx281_fail - rxcap_285_done: + goto rxcap_287_done + rxcap_287_fail: + goto rx283_fail + rxcap_287_done: # rx charclass s - ge rx281_pos, rx281_eos, rx281_fail - sub $I10, rx281_pos, rx281_off - is_cclass $I11, 32, rx281_tgt, $I10 - unless $I11, rx281_fail - inc rx281_pos + ge rx283_pos, rx283_eos, rx283_fail + sub $I10, rx283_pos, rx283_off + is_cclass $I11, 32, rx283_tgt, $I10 + unless $I11, rx283_fail + inc rx283_pos # rx subrule "ws" subtype=method negate= - rx281_cur."!cursor_pos"(rx281_pos) - $P10 = rx281_cur."ws"() - unless $P10, rx281_fail - rx281_pos = $P10."pos"() -.annotate 'line', 165 + rx283_cur."!cursor_pos"(rx283_pos) + $P10 = rx283_cur."ws"() + unless $P10, rx283_fail + rx283_pos = $P10."pos"() +.annotate 'line', 166 # rx subrule "xblock" subtype=capture negate= - rx281_cur."!cursor_pos"(rx281_pos) - $P10 = rx281_cur."xblock"() - unless $P10, rx281_fail - rx281_cur."!mark_push"(0, -1, 0, $P10) + rx283_cur."!cursor_pos"(rx283_pos) + $P10 = rx283_cur."xblock"() + unless $P10, rx283_fail + rx283_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("xblock") - rx281_pos = $P10."pos"() + rx283_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx281_cur."!cursor_pos"(rx281_pos) - $P10 = rx281_cur."ws"() - unless $P10, rx281_fail - rx281_pos = $P10."pos"() - alt288_0: -.annotate 'line', 166 - set_addr $I10, alt288_1 - rx281_cur."!mark_push"(0, rx281_pos, $I10) + rx283_cur."!cursor_pos"(rx283_pos) + $P10 = rx283_cur."ws"() + unless $P10, rx283_fail + rx283_pos = $P10."pos"() + alt290_0: +.annotate 'line', 167 + set_addr $I10, alt290_1 + rx283_cur."!mark_push"(0, rx283_pos, $I10) # rx subrule "ws" subtype=method negate= - rx281_cur."!cursor_pos"(rx281_pos) - $P10 = rx281_cur."ws"() - unless $P10, rx281_fail - rx281_pos = $P10."pos"() + rx283_cur."!cursor_pos"(rx283_pos) + $P10 = rx283_cur."ws"() + unless $P10, rx283_fail + rx283_pos = $P10."pos"() # rx subrule "before" subtype=zerowidth negate=1 - rx281_cur."!cursor_pos"(rx281_pos) - .const 'Sub' $P291 = "66_1275511697.61926" - capture_lex $P291 - $P10 = rx281_cur."before"($P291) - if $P10, rx281_fail + rx283_cur."!cursor_pos"(rx283_pos) + .const 'Sub' $P293 = "66_1275600007.84296" + capture_lex $P293 + $P10 = rx283_cur."before"($P293) + if $P10, rx283_fail # rx subrule "ws" subtype=method negate= - rx281_cur."!cursor_pos"(rx281_pos) - $P10 = rx281_cur."ws"() - unless $P10, rx281_fail - rx281_pos = $P10."pos"() - goto alt288_end - alt288_1: + rx283_cur."!cursor_pos"(rx283_pos) + $P10 = rx283_cur."ws"() + unless $P10, rx283_fail + rx283_pos = $P10."pos"() + goto alt290_end + alt290_1: # rx subrule "ws" subtype=method negate= - rx281_cur."!cursor_pos"(rx281_pos) - $P10 = rx281_cur."ws"() - unless $P10, rx281_fail - rx281_pos = $P10."pos"() + rx283_cur."!cursor_pos"(rx283_pos) + $P10 = rx283_cur."ws"() + unless $P10, rx283_fail + rx283_pos = $P10."pos"() # rx subrule "panic" subtype=method negate= - rx281_cur."!cursor_pos"(rx281_pos) - $P10 = rx281_cur."panic"("unless does not take \"else\", please rewrite using \"if\"") - unless $P10, rx281_fail - rx281_pos = $P10."pos"() + rx283_cur."!cursor_pos"(rx283_pos) + $P10 = rx283_cur."panic"("unless does not take \"else\", please rewrite using \"if\"") + unless $P10, rx283_fail + rx283_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx281_cur."!cursor_pos"(rx281_pos) - $P10 = rx281_cur."ws"() - unless $P10, rx281_fail - rx281_pos = $P10."pos"() - alt288_end: + rx283_cur."!cursor_pos"(rx283_pos) + $P10 = rx283_cur."ws"() + unless $P10, rx283_fail + rx283_pos = $P10."pos"() + alt290_end: # rx subrule "ws" subtype=method negate= - rx281_cur."!cursor_pos"(rx281_pos) - $P10 = rx281_cur."ws"() - unless $P10, rx281_fail - rx281_pos = $P10."pos"() -.annotate 'line', 163 + rx283_cur."!cursor_pos"(rx283_pos) + $P10 = rx283_cur."ws"() + unless $P10, rx283_fail + rx283_pos = $P10."pos"() +.annotate 'line', 164 # rx pass - rx281_cur."!cursor_pass"(rx281_pos, "statement_control:sym") - rx281_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx281_pos) - .return (rx281_cur) - rx281_fail: -.annotate 'line', 4 - (rx281_rep, rx281_pos, $I10, $P10) = rx281_cur."!mark_fail"(0) - lt rx281_pos, -1, rx281_done - eq rx281_pos, -1, rx281_fail + rx283_cur."!cursor_pass"(rx283_pos, "statement_control:sym") + rx283_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx283_pos) + .return (rx283_cur) + rx283_fail: +.annotate 'line', 4 + (rx283_rep, rx283_pos, $I10, $P10) = rx283_cur."!mark_fail"(0) + lt rx283_pos, -1, rx283_done + eq rx283_pos, -1, rx283_fail jump $I10 - rx281_done: - rx281_cur."!cursor_fail"() - rx281_cur."!cursor_debug"("FAIL ", "statement_control:sym") - .return (rx281_cur) + rx283_done: + rx283_cur."!cursor_fail"() + rx283_cur."!cursor_debug"("FAIL ", "statement_control:sym") + .return (rx283_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_control:sym" :subid("65_1275511697.61926") :method +.sub "!PREFIX__statement_control:sym" :subid("65_1275600007.84296") :method .annotate 'line', 4 - new $P283, "ResizablePMCArray" - push $P283, "unless" - .return ($P283) + new $P285, "ResizablePMCArray" + push $P285, "unless" + .return ($P285) .end .namespace ["NQP";"Grammar"] -.sub "_block290" :anon :subid("66_1275511697.61926") :method :outer("64_1275511697.61926") -.annotate 'line', 166 - .local string rx292_tgt - .local int rx292_pos - .local int rx292_off - .local int rx292_eos - .local int rx292_rep - .local pmc rx292_cur - (rx292_cur, rx292_pos, rx292_tgt) = self."!cursor_start"() - rx292_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx292_cur +.sub "_block292" :anon :subid("66_1275600007.84296") :method :outer("64_1275600007.84296") +.annotate 'line', 167 + .local string rx294_tgt + .local int rx294_pos + .local int rx294_off + .local int rx294_eos + .local int rx294_rep + .local pmc rx294_cur + (rx294_cur, rx294_pos, rx294_tgt) = self."!cursor_start"() + rx294_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx294_cur .local pmc match .lex "$/", match - length rx292_eos, rx292_tgt - gt rx292_pos, rx292_eos, rx292_done - set rx292_off, 0 - lt rx292_pos, 2, rx292_start - sub rx292_off, rx292_pos, 1 - substr rx292_tgt, rx292_tgt, rx292_off - rx292_start: + length rx294_eos, rx294_tgt + gt rx294_pos, rx294_eos, rx294_done + set rx294_off, 0 + lt rx294_pos, 2, rx294_start + sub rx294_off, rx294_pos, 1 + substr rx294_tgt, rx294_tgt, rx294_off + rx294_start: $I10 = self.'from'() - ne $I10, -1, rxscan293_done - goto rxscan293_scan - rxscan293_loop: - ($P10) = rx292_cur."from"() + ne $I10, -1, rxscan295_done + goto rxscan295_scan + rxscan295_loop: + ($P10) = rx294_cur."from"() inc $P10 - set rx292_pos, $P10 - ge rx292_pos, rx292_eos, rxscan293_done - rxscan293_scan: - set_addr $I10, rxscan293_loop - rx292_cur."!mark_push"(0, rx292_pos, $I10) - rxscan293_done: + set rx294_pos, $P10 + ge rx294_pos, rx294_eos, rxscan295_done + rxscan295_scan: + set_addr $I10, rxscan295_loop + rx294_cur."!mark_push"(0, rx294_pos, $I10) + rxscan295_done: # rx literal "else" - add $I11, rx292_pos, 4 - gt $I11, rx292_eos, rx292_fail - sub $I11, rx292_pos, rx292_off - substr $S10, rx292_tgt, $I11, 4 - ne $S10, "else", rx292_fail - add rx292_pos, 4 + add $I11, rx294_pos, 4 + gt $I11, rx294_eos, rx294_fail + sub $I11, rx294_pos, rx294_off + substr $S10, rx294_tgt, $I11, 4 + ne $S10, "else", rx294_fail + add rx294_pos, 4 # rx pass - rx292_cur."!cursor_pass"(rx292_pos, "") - rx292_cur."!cursor_debug"("PASS ", "", " at pos=", rx292_pos) - .return (rx292_cur) - rx292_fail: - (rx292_rep, rx292_pos, $I10, $P10) = rx292_cur."!mark_fail"(0) - lt rx292_pos, -1, rx292_done - eq rx292_pos, -1, rx292_fail + rx294_cur."!cursor_pass"(rx294_pos, "") + rx294_cur."!cursor_debug"("PASS ", "", " at pos=", rx294_pos) + .return (rx294_cur) + rx294_fail: + (rx294_rep, rx294_pos, $I10, $P10) = rx294_cur."!mark_fail"(0) + lt rx294_pos, -1, rx294_done + eq rx294_pos, -1, rx294_fail jump $I10 - rx292_done: - rx292_cur."!cursor_fail"() - rx292_cur."!cursor_debug"("FAIL ", "") - .return (rx292_cur) + rx294_done: + rx294_cur."!cursor_fail"() + rx294_cur."!cursor_debug"("FAIL ", "") + .return (rx294_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "statement_control:sym" :subid("67_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement_control:sym" :subid("67_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx299_tgt - .local int rx299_pos - .local int rx299_off - .local int rx299_eos - .local int rx299_rep - .local pmc rx299_cur - (rx299_cur, rx299_pos, rx299_tgt) = self."!cursor_start"() - rx299_cur."!cursor_debug"("START ", "statement_control:sym") - .lex unicode:"$\x{a2}", rx299_cur + .local string rx301_tgt + .local int rx301_pos + .local int rx301_off + .local int rx301_eos + .local int rx301_rep + .local pmc rx301_cur + (rx301_cur, rx301_pos, rx301_tgt) = self."!cursor_start"() + rx301_cur."!cursor_debug"("START ", "statement_control:sym") + .lex unicode:"$\x{a2}", rx301_cur .local pmc match .lex "$/", match - length rx299_eos, rx299_tgt - gt rx299_pos, rx299_eos, rx299_done - set rx299_off, 0 - lt rx299_pos, 2, rx299_start - sub rx299_off, rx299_pos, 1 - substr rx299_tgt, rx299_tgt, rx299_off - rx299_start: + length rx301_eos, rx301_tgt + gt rx301_pos, rx301_eos, rx301_done + set rx301_off, 0 + lt rx301_pos, 2, rx301_start + sub rx301_off, rx301_pos, 1 + substr rx301_tgt, rx301_tgt, rx301_off + rx301_start: $I10 = self.'from'() - ne $I10, -1, rxscan302_done - goto rxscan302_scan - rxscan302_loop: - ($P10) = rx299_cur."from"() + ne $I10, -1, rxscan304_done + goto rxscan304_scan + rxscan304_loop: + ($P10) = rx301_cur."from"() inc $P10 - set rx299_pos, $P10 - ge rx299_pos, rx299_eos, rxscan302_done - rxscan302_scan: - set_addr $I10, rxscan302_loop - rx299_cur."!mark_push"(0, rx299_pos, $I10) - rxscan302_done: -.annotate 'line', 170 + set rx301_pos, $P10 + ge rx301_pos, rx301_eos, rxscan304_done + rxscan304_scan: + set_addr $I10, rxscan304_loop + rx301_cur."!mark_push"(0, rx301_pos, $I10) + rxscan304_done: +.annotate 'line', 171 # rx subcapture "sym" - set_addr $I10, rxcap_304_fail - rx299_cur."!mark_push"(0, rx299_pos, $I10) - alt303_0: - set_addr $I10, alt303_1 - rx299_cur."!mark_push"(0, rx299_pos, $I10) + set_addr $I10, rxcap_306_fail + rx301_cur."!mark_push"(0, rx301_pos, $I10) + alt305_0: + set_addr $I10, alt305_1 + rx301_cur."!mark_push"(0, rx301_pos, $I10) # rx literal "while" - add $I11, rx299_pos, 5 - gt $I11, rx299_eos, rx299_fail - sub $I11, rx299_pos, rx299_off - substr $S10, rx299_tgt, $I11, 5 - ne $S10, "while", rx299_fail - add rx299_pos, 5 - goto alt303_end - alt303_1: + add $I11, rx301_pos, 5 + gt $I11, rx301_eos, rx301_fail + sub $I11, rx301_pos, rx301_off + substr $S10, rx301_tgt, $I11, 5 + ne $S10, "while", rx301_fail + add rx301_pos, 5 + goto alt305_end + alt305_1: # rx literal "until" - add $I11, rx299_pos, 5 - gt $I11, rx299_eos, rx299_fail - sub $I11, rx299_pos, rx299_off - substr $S10, rx299_tgt, $I11, 5 - ne $S10, "until", rx299_fail - add rx299_pos, 5 - alt303_end: - set_addr $I10, rxcap_304_fail - ($I12, $I11) = rx299_cur."!mark_peek"($I10) - rx299_cur."!cursor_pos"($I11) - ($P10) = rx299_cur."!cursor_start"() - $P10."!cursor_pass"(rx299_pos, "") - rx299_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx301_pos, 5 + gt $I11, rx301_eos, rx301_fail + sub $I11, rx301_pos, rx301_off + substr $S10, rx301_tgt, $I11, 5 + ne $S10, "until", rx301_fail + add rx301_pos, 5 + alt305_end: + set_addr $I10, rxcap_306_fail + ($I12, $I11) = rx301_cur."!mark_peek"($I10) + rx301_cur."!cursor_pos"($I11) + ($P10) = rx301_cur."!cursor_start"() + $P10."!cursor_pass"(rx301_pos, "") + rx301_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_304_done - rxcap_304_fail: - goto rx299_fail - rxcap_304_done: + goto rxcap_306_done + rxcap_306_fail: + goto rx301_fail + rxcap_306_done: # rx charclass s - ge rx299_pos, rx299_eos, rx299_fail - sub $I10, rx299_pos, rx299_off - is_cclass $I11, 32, rx299_tgt, $I10 - unless $I11, rx299_fail - inc rx299_pos + ge rx301_pos, rx301_eos, rx301_fail + sub $I10, rx301_pos, rx301_off + is_cclass $I11, 32, rx301_tgt, $I10 + unless $I11, rx301_fail + inc rx301_pos # rx subrule "ws" subtype=method negate= - rx299_cur."!cursor_pos"(rx299_pos) - $P10 = rx299_cur."ws"() - unless $P10, rx299_fail - rx299_pos = $P10."pos"() -.annotate 'line', 171 + rx301_cur."!cursor_pos"(rx301_pos) + $P10 = rx301_cur."ws"() + unless $P10, rx301_fail + rx301_pos = $P10."pos"() +.annotate 'line', 172 # rx subrule "xblock" subtype=capture negate= - rx299_cur."!cursor_pos"(rx299_pos) - $P10 = rx299_cur."xblock"() - unless $P10, rx299_fail - rx299_cur."!mark_push"(0, -1, 0, $P10) + rx301_cur."!cursor_pos"(rx301_pos) + $P10 = rx301_cur."xblock"() + unless $P10, rx301_fail + rx301_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("xblock") - rx299_pos = $P10."pos"() + rx301_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx299_cur."!cursor_pos"(rx299_pos) - $P10 = rx299_cur."ws"() - unless $P10, rx299_fail - rx299_pos = $P10."pos"() -.annotate 'line', 169 + rx301_cur."!cursor_pos"(rx301_pos) + $P10 = rx301_cur."ws"() + unless $P10, rx301_fail + rx301_pos = $P10."pos"() +.annotate 'line', 170 # rx pass - rx299_cur."!cursor_pass"(rx299_pos, "statement_control:sym") - rx299_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx299_pos) - .return (rx299_cur) - rx299_fail: -.annotate 'line', 4 - (rx299_rep, rx299_pos, $I10, $P10) = rx299_cur."!mark_fail"(0) - lt rx299_pos, -1, rx299_done - eq rx299_pos, -1, rx299_fail + rx301_cur."!cursor_pass"(rx301_pos, "statement_control:sym") + rx301_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx301_pos) + .return (rx301_cur) + rx301_fail: +.annotate 'line', 4 + (rx301_rep, rx301_pos, $I10, $P10) = rx301_cur."!mark_fail"(0) + lt rx301_pos, -1, rx301_done + eq rx301_pos, -1, rx301_fail jump $I10 - rx299_done: - rx299_cur."!cursor_fail"() - rx299_cur."!cursor_debug"("FAIL ", "statement_control:sym") - .return (rx299_cur) + rx301_done: + rx301_cur."!cursor_fail"() + rx301_cur."!cursor_debug"("FAIL ", "statement_control:sym") + .return (rx301_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_control:sym" :subid("68_1275511697.61926") :method +.sub "!PREFIX__statement_control:sym" :subid("68_1275600007.84296") :method .annotate 'line', 4 - new $P301, "ResizablePMCArray" - push $P301, "until" - push $P301, "while" - .return ($P301) + new $P303, "ResizablePMCArray" + push $P303, "until" + push $P303, "while" + .return ($P303) .end .namespace ["NQP";"Grammar"] -.sub "statement_control:sym" :subid("69_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement_control:sym" :subid("69_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx308_tgt - .local int rx308_pos - .local int rx308_off - .local int rx308_eos - .local int rx308_rep - .local pmc rx308_cur - (rx308_cur, rx308_pos, rx308_tgt) = self."!cursor_start"() - rx308_cur."!cursor_debug"("START ", "statement_control:sym") - .lex unicode:"$\x{a2}", rx308_cur + .local string rx310_tgt + .local int rx310_pos + .local int rx310_off + .local int rx310_eos + .local int rx310_rep + .local pmc rx310_cur + (rx310_cur, rx310_pos, rx310_tgt) = self."!cursor_start"() + rx310_cur."!cursor_debug"("START ", "statement_control:sym") + .lex unicode:"$\x{a2}", rx310_cur .local pmc match .lex "$/", match - length rx308_eos, rx308_tgt - gt rx308_pos, rx308_eos, rx308_done - set rx308_off, 0 - lt rx308_pos, 2, rx308_start - sub rx308_off, rx308_pos, 1 - substr rx308_tgt, rx308_tgt, rx308_off - rx308_start: + length rx310_eos, rx310_tgt + gt rx310_pos, rx310_eos, rx310_done + set rx310_off, 0 + lt rx310_pos, 2, rx310_start + sub rx310_off, rx310_pos, 1 + substr rx310_tgt, rx310_tgt, rx310_off + rx310_start: $I10 = self.'from'() - ne $I10, -1, rxscan311_done - goto rxscan311_scan - rxscan311_loop: - ($P10) = rx308_cur."from"() + ne $I10, -1, rxscan313_done + goto rxscan313_scan + rxscan313_loop: + ($P10) = rx310_cur."from"() inc $P10 - set rx308_pos, $P10 - ge rx308_pos, rx308_eos, rxscan311_done - rxscan311_scan: - set_addr $I10, rxscan311_loop - rx308_cur."!mark_push"(0, rx308_pos, $I10) - rxscan311_done: -.annotate 'line', 175 + set rx310_pos, $P10 + ge rx310_pos, rx310_eos, rxscan313_done + rxscan313_scan: + set_addr $I10, rxscan313_loop + rx310_cur."!mark_push"(0, rx310_pos, $I10) + rxscan313_done: +.annotate 'line', 176 # rx subcapture "sym" - set_addr $I10, rxcap_312_fail - rx308_cur."!mark_push"(0, rx308_pos, $I10) + set_addr $I10, rxcap_314_fail + rx310_cur."!mark_push"(0, rx310_pos, $I10) # rx literal "repeat" - add $I11, rx308_pos, 6 - gt $I11, rx308_eos, rx308_fail - sub $I11, rx308_pos, rx308_off - substr $S10, rx308_tgt, $I11, 6 - ne $S10, "repeat", rx308_fail - add rx308_pos, 6 - set_addr $I10, rxcap_312_fail - ($I12, $I11) = rx308_cur."!mark_peek"($I10) - rx308_cur."!cursor_pos"($I11) - ($P10) = rx308_cur."!cursor_start"() - $P10."!cursor_pass"(rx308_pos, "") - rx308_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx310_pos, 6 + gt $I11, rx310_eos, rx310_fail + sub $I11, rx310_pos, rx310_off + substr $S10, rx310_tgt, $I11, 6 + ne $S10, "repeat", rx310_fail + add rx310_pos, 6 + set_addr $I10, rxcap_314_fail + ($I12, $I11) = rx310_cur."!mark_peek"($I10) + rx310_cur."!cursor_pos"($I11) + ($P10) = rx310_cur."!cursor_start"() + $P10."!cursor_pass"(rx310_pos, "") + rx310_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_312_done - rxcap_312_fail: - goto rx308_fail - rxcap_312_done: + goto rxcap_314_done + rxcap_314_fail: + goto rx310_fail + rxcap_314_done: # rx charclass s - ge rx308_pos, rx308_eos, rx308_fail - sub $I10, rx308_pos, rx308_off - is_cclass $I11, 32, rx308_tgt, $I10 - unless $I11, rx308_fail - inc rx308_pos + ge rx310_pos, rx310_eos, rx310_fail + sub $I10, rx310_pos, rx310_off + is_cclass $I11, 32, rx310_tgt, $I10 + unless $I11, rx310_fail + inc rx310_pos # rx subrule "ws" subtype=method negate= - rx308_cur."!cursor_pos"(rx308_pos) - $P10 = rx308_cur."ws"() - unless $P10, rx308_fail - rx308_pos = $P10."pos"() - alt314_0: -.annotate 'line', 176 - set_addr $I10, alt314_1 - rx308_cur."!mark_push"(0, rx308_pos, $I10) + rx310_cur."!cursor_pos"(rx310_pos) + $P10 = rx310_cur."ws"() + unless $P10, rx310_fail + rx310_pos = $P10."pos"() + alt316_0: .annotate 'line', 177 + set_addr $I10, alt316_1 + rx310_cur."!mark_push"(0, rx310_pos, $I10) +.annotate 'line', 178 # rx subrule "ws" subtype=method negate= - rx308_cur."!cursor_pos"(rx308_pos) - $P10 = rx308_cur."ws"() - unless $P10, rx308_fail - rx308_pos = $P10."pos"() + rx310_cur."!cursor_pos"(rx310_pos) + $P10 = rx310_cur."ws"() + unless $P10, rx310_fail + rx310_pos = $P10."pos"() # rx subcapture "wu" - set_addr $I10, rxcap_317_fail - rx308_cur."!mark_push"(0, rx308_pos, $I10) - alt316_0: - set_addr $I10, alt316_1 - rx308_cur."!mark_push"(0, rx308_pos, $I10) + set_addr $I10, rxcap_319_fail + rx310_cur."!mark_push"(0, rx310_pos, $I10) + alt318_0: + set_addr $I10, alt318_1 + rx310_cur."!mark_push"(0, rx310_pos, $I10) # rx literal "while" - add $I11, rx308_pos, 5 - gt $I11, rx308_eos, rx308_fail - sub $I11, rx308_pos, rx308_off - substr $S10, rx308_tgt, $I11, 5 - ne $S10, "while", rx308_fail - add rx308_pos, 5 - goto alt316_end - alt316_1: + add $I11, rx310_pos, 5 + gt $I11, rx310_eos, rx310_fail + sub $I11, rx310_pos, rx310_off + substr $S10, rx310_tgt, $I11, 5 + ne $S10, "while", rx310_fail + add rx310_pos, 5 + goto alt318_end + alt318_1: # rx literal "until" - add $I11, rx308_pos, 5 - gt $I11, rx308_eos, rx308_fail - sub $I11, rx308_pos, rx308_off - substr $S10, rx308_tgt, $I11, 5 - ne $S10, "until", rx308_fail - add rx308_pos, 5 - alt316_end: - set_addr $I10, rxcap_317_fail - ($I12, $I11) = rx308_cur."!mark_peek"($I10) - rx308_cur."!cursor_pos"($I11) - ($P10) = rx308_cur."!cursor_start"() - $P10."!cursor_pass"(rx308_pos, "") - rx308_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx310_pos, 5 + gt $I11, rx310_eos, rx310_fail + sub $I11, rx310_pos, rx310_off + substr $S10, rx310_tgt, $I11, 5 + ne $S10, "until", rx310_fail + add rx310_pos, 5 + alt318_end: + set_addr $I10, rxcap_319_fail + ($I12, $I11) = rx310_cur."!mark_peek"($I10) + rx310_cur."!cursor_pos"($I11) + ($P10) = rx310_cur."!cursor_start"() + $P10."!cursor_pass"(rx310_pos, "") + rx310_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("wu") - goto rxcap_317_done - rxcap_317_fail: - goto rx308_fail - rxcap_317_done: + goto rxcap_319_done + rxcap_319_fail: + goto rx310_fail + rxcap_319_done: # rx charclass s - ge rx308_pos, rx308_eos, rx308_fail - sub $I10, rx308_pos, rx308_off - is_cclass $I11, 32, rx308_tgt, $I10 - unless $I11, rx308_fail - inc rx308_pos + ge rx310_pos, rx310_eos, rx310_fail + sub $I10, rx310_pos, rx310_off + is_cclass $I11, 32, rx310_tgt, $I10 + unless $I11, rx310_fail + inc rx310_pos # rx subrule "ws" subtype=method negate= - rx308_cur."!cursor_pos"(rx308_pos) - $P10 = rx308_cur."ws"() - unless $P10, rx308_fail - rx308_pos = $P10."pos"() + rx310_cur."!cursor_pos"(rx310_pos) + $P10 = rx310_cur."ws"() + unless $P10, rx310_fail + rx310_pos = $P10."pos"() # rx subrule "xblock" subtype=capture negate= - rx308_cur."!cursor_pos"(rx308_pos) - $P10 = rx308_cur."xblock"() - unless $P10, rx308_fail - rx308_cur."!mark_push"(0, -1, 0, $P10) + rx310_cur."!cursor_pos"(rx310_pos) + $P10 = rx310_cur."xblock"() + unless $P10, rx310_fail + rx310_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("xblock") - rx308_pos = $P10."pos"() + rx310_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx308_cur."!cursor_pos"(rx308_pos) - $P10 = rx308_cur."ws"() - unless $P10, rx308_fail - rx308_pos = $P10."pos"() - goto alt314_end - alt314_1: -.annotate 'line', 178 + rx310_cur."!cursor_pos"(rx310_pos) + $P10 = rx310_cur."ws"() + unless $P10, rx310_fail + rx310_pos = $P10."pos"() + goto alt316_end + alt316_1: +.annotate 'line', 179 # rx subrule "ws" subtype=method negate= - rx308_cur."!cursor_pos"(rx308_pos) - $P10 = rx308_cur."ws"() - unless $P10, rx308_fail - rx308_pos = $P10."pos"() + rx310_cur."!cursor_pos"(rx310_pos) + $P10 = rx310_cur."ws"() + unless $P10, rx310_fail + rx310_pos = $P10."pos"() # rx subrule "pblock" subtype=capture negate= - rx308_cur."!cursor_pos"(rx308_pos) - $P10 = rx308_cur."pblock"() - unless $P10, rx308_fail - rx308_cur."!mark_push"(0, -1, 0, $P10) + rx310_cur."!cursor_pos"(rx310_pos) + $P10 = rx310_cur."pblock"() + unless $P10, rx310_fail + rx310_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("pblock") - rx308_pos = $P10."pos"() + rx310_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx308_cur."!cursor_pos"(rx308_pos) - $P10 = rx308_cur."ws"() - unless $P10, rx308_fail - rx308_pos = $P10."pos"() + rx310_cur."!cursor_pos"(rx310_pos) + $P10 = rx310_cur."ws"() + unless $P10, rx310_fail + rx310_pos = $P10."pos"() # rx subcapture "wu" - set_addr $I10, rxcap_323_fail - rx308_cur."!mark_push"(0, rx308_pos, $I10) - alt322_0: - set_addr $I10, alt322_1 - rx308_cur."!mark_push"(0, rx308_pos, $I10) + set_addr $I10, rxcap_325_fail + rx310_cur."!mark_push"(0, rx310_pos, $I10) + alt324_0: + set_addr $I10, alt324_1 + rx310_cur."!mark_push"(0, rx310_pos, $I10) # rx literal "while" - add $I11, rx308_pos, 5 - gt $I11, rx308_eos, rx308_fail - sub $I11, rx308_pos, rx308_off - substr $S10, rx308_tgt, $I11, 5 - ne $S10, "while", rx308_fail - add rx308_pos, 5 - goto alt322_end - alt322_1: + add $I11, rx310_pos, 5 + gt $I11, rx310_eos, rx310_fail + sub $I11, rx310_pos, rx310_off + substr $S10, rx310_tgt, $I11, 5 + ne $S10, "while", rx310_fail + add rx310_pos, 5 + goto alt324_end + alt324_1: # rx literal "until" - add $I11, rx308_pos, 5 - gt $I11, rx308_eos, rx308_fail - sub $I11, rx308_pos, rx308_off - substr $S10, rx308_tgt, $I11, 5 - ne $S10, "until", rx308_fail - add rx308_pos, 5 - alt322_end: - set_addr $I10, rxcap_323_fail - ($I12, $I11) = rx308_cur."!mark_peek"($I10) - rx308_cur."!cursor_pos"($I11) - ($P10) = rx308_cur."!cursor_start"() - $P10."!cursor_pass"(rx308_pos, "") - rx308_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx310_pos, 5 + gt $I11, rx310_eos, rx310_fail + sub $I11, rx310_pos, rx310_off + substr $S10, rx310_tgt, $I11, 5 + ne $S10, "until", rx310_fail + add rx310_pos, 5 + alt324_end: + set_addr $I10, rxcap_325_fail + ($I12, $I11) = rx310_cur."!mark_peek"($I10) + rx310_cur."!cursor_pos"($I11) + ($P10) = rx310_cur."!cursor_start"() + $P10."!cursor_pass"(rx310_pos, "") + rx310_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("wu") - goto rxcap_323_done - rxcap_323_fail: - goto rx308_fail - rxcap_323_done: + goto rxcap_325_done + rxcap_325_fail: + goto rx310_fail + rxcap_325_done: # rx charclass s - ge rx308_pos, rx308_eos, rx308_fail - sub $I10, rx308_pos, rx308_off - is_cclass $I11, 32, rx308_tgt, $I10 - unless $I11, rx308_fail - inc rx308_pos + ge rx310_pos, rx310_eos, rx310_fail + sub $I10, rx310_pos, rx310_off + is_cclass $I11, 32, rx310_tgt, $I10 + unless $I11, rx310_fail + inc rx310_pos # rx subrule "ws" subtype=method negate= - rx308_cur."!cursor_pos"(rx308_pos) - $P10 = rx308_cur."ws"() - unless $P10, rx308_fail - rx308_pos = $P10."pos"() + rx310_cur."!cursor_pos"(rx310_pos) + $P10 = rx310_cur."ws"() + unless $P10, rx310_fail + rx310_pos = $P10."pos"() # rx subrule "EXPR" subtype=capture negate= - rx308_cur."!cursor_pos"(rx308_pos) - $P10 = rx308_cur."EXPR"() - unless $P10, rx308_fail - rx308_cur."!mark_push"(0, -1, 0, $P10) + rx310_cur."!cursor_pos"(rx310_pos) + $P10 = rx310_cur."EXPR"() + unless $P10, rx310_fail + rx310_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("EXPR") - rx308_pos = $P10."pos"() + rx310_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx308_cur."!cursor_pos"(rx308_pos) - $P10 = rx308_cur."ws"() - unless $P10, rx308_fail - rx308_pos = $P10."pos"() - alt314_end: -.annotate 'line', 179 + rx310_cur."!cursor_pos"(rx310_pos) + $P10 = rx310_cur."ws"() + unless $P10, rx310_fail + rx310_pos = $P10."pos"() + alt316_end: +.annotate 'line', 180 # rx subrule "ws" subtype=method negate= - rx308_cur."!cursor_pos"(rx308_pos) - $P10 = rx308_cur."ws"() - unless $P10, rx308_fail - rx308_pos = $P10."pos"() -.annotate 'line', 174 + rx310_cur."!cursor_pos"(rx310_pos) + $P10 = rx310_cur."ws"() + unless $P10, rx310_fail + rx310_pos = $P10."pos"() +.annotate 'line', 175 # rx pass - rx308_cur."!cursor_pass"(rx308_pos, "statement_control:sym") - rx308_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx308_pos) - .return (rx308_cur) - rx308_fail: -.annotate 'line', 4 - (rx308_rep, rx308_pos, $I10, $P10) = rx308_cur."!mark_fail"(0) - lt rx308_pos, -1, rx308_done - eq rx308_pos, -1, rx308_fail + rx310_cur."!cursor_pass"(rx310_pos, "statement_control:sym") + rx310_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx310_pos) + .return (rx310_cur) + rx310_fail: +.annotate 'line', 4 + (rx310_rep, rx310_pos, $I10, $P10) = rx310_cur."!mark_fail"(0) + lt rx310_pos, -1, rx310_done + eq rx310_pos, -1, rx310_fail jump $I10 - rx308_done: - rx308_cur."!cursor_fail"() - rx308_cur."!cursor_debug"("FAIL ", "statement_control:sym") - .return (rx308_cur) + rx310_done: + rx310_cur."!cursor_fail"() + rx310_cur."!cursor_debug"("FAIL ", "statement_control:sym") + .return (rx310_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_control:sym" :subid("70_1275511697.61926") :method +.sub "!PREFIX__statement_control:sym" :subid("70_1275600007.84296") :method .annotate 'line', 4 - new $P310, "ResizablePMCArray" - push $P310, "repeat" - .return ($P310) + new $P312, "ResizablePMCArray" + push $P312, "repeat" + .return ($P312) .end .namespace ["NQP";"Grammar"] -.sub "statement_control:sym" :subid("71_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement_control:sym" :subid("71_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx328_tgt - .local int rx328_pos - .local int rx328_off - .local int rx328_eos - .local int rx328_rep - .local pmc rx328_cur - (rx328_cur, rx328_pos, rx328_tgt) = self."!cursor_start"() - rx328_cur."!cursor_debug"("START ", "statement_control:sym") - .lex unicode:"$\x{a2}", rx328_cur + .local string rx330_tgt + .local int rx330_pos + .local int rx330_off + .local int rx330_eos + .local int rx330_rep + .local pmc rx330_cur + (rx330_cur, rx330_pos, rx330_tgt) = self."!cursor_start"() + rx330_cur."!cursor_debug"("START ", "statement_control:sym") + .lex unicode:"$\x{a2}", rx330_cur .local pmc match .lex "$/", match - length rx328_eos, rx328_tgt - gt rx328_pos, rx328_eos, rx328_done - set rx328_off, 0 - lt rx328_pos, 2, rx328_start - sub rx328_off, rx328_pos, 1 - substr rx328_tgt, rx328_tgt, rx328_off - rx328_start: + length rx330_eos, rx330_tgt + gt rx330_pos, rx330_eos, rx330_done + set rx330_off, 0 + lt rx330_pos, 2, rx330_start + sub rx330_off, rx330_pos, 1 + substr rx330_tgt, rx330_tgt, rx330_off + rx330_start: $I10 = self.'from'() - ne $I10, -1, rxscan331_done - goto rxscan331_scan - rxscan331_loop: - ($P10) = rx328_cur."from"() + ne $I10, -1, rxscan333_done + goto rxscan333_scan + rxscan333_loop: + ($P10) = rx330_cur."from"() inc $P10 - set rx328_pos, $P10 - ge rx328_pos, rx328_eos, rxscan331_done - rxscan331_scan: - set_addr $I10, rxscan331_loop - rx328_cur."!mark_push"(0, rx328_pos, $I10) - rxscan331_done: -.annotate 'line', 183 + set rx330_pos, $P10 + ge rx330_pos, rx330_eos, rxscan333_done + rxscan333_scan: + set_addr $I10, rxscan333_loop + rx330_cur."!mark_push"(0, rx330_pos, $I10) + rxscan333_done: +.annotate 'line', 184 # rx subcapture "sym" - set_addr $I10, rxcap_332_fail - rx328_cur."!mark_push"(0, rx328_pos, $I10) + set_addr $I10, rxcap_334_fail + rx330_cur."!mark_push"(0, rx330_pos, $I10) # rx literal "for" - add $I11, rx328_pos, 3 - gt $I11, rx328_eos, rx328_fail - sub $I11, rx328_pos, rx328_off - substr $S10, rx328_tgt, $I11, 3 - ne $S10, "for", rx328_fail - add rx328_pos, 3 - set_addr $I10, rxcap_332_fail - ($I12, $I11) = rx328_cur."!mark_peek"($I10) - rx328_cur."!cursor_pos"($I11) - ($P10) = rx328_cur."!cursor_start"() - $P10."!cursor_pass"(rx328_pos, "") - rx328_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx330_pos, 3 + gt $I11, rx330_eos, rx330_fail + sub $I11, rx330_pos, rx330_off + substr $S10, rx330_tgt, $I11, 3 + ne $S10, "for", rx330_fail + add rx330_pos, 3 + set_addr $I10, rxcap_334_fail + ($I12, $I11) = rx330_cur."!mark_peek"($I10) + rx330_cur."!cursor_pos"($I11) + ($P10) = rx330_cur."!cursor_start"() + $P10."!cursor_pass"(rx330_pos, "") + rx330_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_332_done - rxcap_332_fail: - goto rx328_fail - rxcap_332_done: + goto rxcap_334_done + rxcap_334_fail: + goto rx330_fail + rxcap_334_done: # rx charclass s - ge rx328_pos, rx328_eos, rx328_fail - sub $I10, rx328_pos, rx328_off - is_cclass $I11, 32, rx328_tgt, $I10 - unless $I11, rx328_fail - inc rx328_pos + ge rx330_pos, rx330_eos, rx330_fail + sub $I10, rx330_pos, rx330_off + is_cclass $I11, 32, rx330_tgt, $I10 + unless $I11, rx330_fail + inc rx330_pos # rx subrule "ws" subtype=method negate= - rx328_cur."!cursor_pos"(rx328_pos) - $P10 = rx328_cur."ws"() - unless $P10, rx328_fail - rx328_pos = $P10."pos"() -.annotate 'line', 184 + rx330_cur."!cursor_pos"(rx330_pos) + $P10 = rx330_cur."ws"() + unless $P10, rx330_fail + rx330_pos = $P10."pos"() +.annotate 'line', 185 # rx subrule "xblock" subtype=capture negate= - rx328_cur."!cursor_pos"(rx328_pos) - $P10 = rx328_cur."xblock"() - unless $P10, rx328_fail - rx328_cur."!mark_push"(0, -1, 0, $P10) + rx330_cur."!cursor_pos"(rx330_pos) + $P10 = rx330_cur."xblock"() + unless $P10, rx330_fail + rx330_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("xblock") - rx328_pos = $P10."pos"() + rx330_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx328_cur."!cursor_pos"(rx328_pos) - $P10 = rx328_cur."ws"() - unless $P10, rx328_fail - rx328_pos = $P10."pos"() -.annotate 'line', 182 + rx330_cur."!cursor_pos"(rx330_pos) + $P10 = rx330_cur."ws"() + unless $P10, rx330_fail + rx330_pos = $P10."pos"() +.annotate 'line', 183 # rx pass - rx328_cur."!cursor_pass"(rx328_pos, "statement_control:sym") - rx328_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx328_pos) - .return (rx328_cur) - rx328_fail: -.annotate 'line', 4 - (rx328_rep, rx328_pos, $I10, $P10) = rx328_cur."!mark_fail"(0) - lt rx328_pos, -1, rx328_done - eq rx328_pos, -1, rx328_fail + rx330_cur."!cursor_pass"(rx330_pos, "statement_control:sym") + rx330_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx330_pos) + .return (rx330_cur) + rx330_fail: +.annotate 'line', 4 + (rx330_rep, rx330_pos, $I10, $P10) = rx330_cur."!mark_fail"(0) + lt rx330_pos, -1, rx330_done + eq rx330_pos, -1, rx330_fail jump $I10 - rx328_done: - rx328_cur."!cursor_fail"() - rx328_cur."!cursor_debug"("FAIL ", "statement_control:sym") - .return (rx328_cur) + rx330_done: + rx330_cur."!cursor_fail"() + rx330_cur."!cursor_debug"("FAIL ", "statement_control:sym") + .return (rx330_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_control:sym" :subid("72_1275511697.61926") :method +.sub "!PREFIX__statement_control:sym" :subid("72_1275600007.84296") :method .annotate 'line', 4 - new $P330, "ResizablePMCArray" - push $P330, "for" - .return ($P330) + new $P332, "ResizablePMCArray" + push $P332, "for" + .return ($P332) .end .namespace ["NQP";"Grammar"] -.sub "statement_control:sym" :subid("73_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement_control:sym" :subid("73_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx336_tgt - .local int rx336_pos - .local int rx336_off - .local int rx336_eos - .local int rx336_rep - .local pmc rx336_cur - (rx336_cur, rx336_pos, rx336_tgt) = self."!cursor_start"() - rx336_cur."!cursor_debug"("START ", "statement_control:sym") - .lex unicode:"$\x{a2}", rx336_cur + .local string rx338_tgt + .local int rx338_pos + .local int rx338_off + .local int rx338_eos + .local int rx338_rep + .local pmc rx338_cur + (rx338_cur, rx338_pos, rx338_tgt) = self."!cursor_start"() + rx338_cur."!cursor_debug"("START ", "statement_control:sym") + .lex unicode:"$\x{a2}", rx338_cur .local pmc match .lex "$/", match - length rx336_eos, rx336_tgt - gt rx336_pos, rx336_eos, rx336_done - set rx336_off, 0 - lt rx336_pos, 2, rx336_start - sub rx336_off, rx336_pos, 1 - substr rx336_tgt, rx336_tgt, rx336_off - rx336_start: + length rx338_eos, rx338_tgt + gt rx338_pos, rx338_eos, rx338_done + set rx338_off, 0 + lt rx338_pos, 2, rx338_start + sub rx338_off, rx338_pos, 1 + substr rx338_tgt, rx338_tgt, rx338_off + rx338_start: $I10 = self.'from'() - ne $I10, -1, rxscan339_done - goto rxscan339_scan - rxscan339_loop: - ($P10) = rx336_cur."from"() + ne $I10, -1, rxscan341_done + goto rxscan341_scan + rxscan341_loop: + ($P10) = rx338_cur."from"() inc $P10 - set rx336_pos, $P10 - ge rx336_pos, rx336_eos, rxscan339_done - rxscan339_scan: - set_addr $I10, rxscan339_loop - rx336_cur."!mark_push"(0, rx336_pos, $I10) - rxscan339_done: -.annotate 'line', 188 + set rx338_pos, $P10 + ge rx338_pos, rx338_eos, rxscan341_done + rxscan341_scan: + set_addr $I10, rxscan341_loop + rx338_cur."!mark_push"(0, rx338_pos, $I10) + rxscan341_done: +.annotate 'line', 189 # rx subcapture "sym" - set_addr $I10, rxcap_340_fail - rx336_cur."!mark_push"(0, rx336_pos, $I10) + set_addr $I10, rxcap_342_fail + rx338_cur."!mark_push"(0, rx338_pos, $I10) # rx literal "CATCH" - add $I11, rx336_pos, 5 - gt $I11, rx336_eos, rx336_fail - sub $I11, rx336_pos, rx336_off - substr $S10, rx336_tgt, $I11, 5 - ne $S10, "CATCH", rx336_fail - add rx336_pos, 5 - set_addr $I10, rxcap_340_fail - ($I12, $I11) = rx336_cur."!mark_peek"($I10) - rx336_cur."!cursor_pos"($I11) - ($P10) = rx336_cur."!cursor_start"() - $P10."!cursor_pass"(rx336_pos, "") - rx336_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx338_pos, 5 + gt $I11, rx338_eos, rx338_fail + sub $I11, rx338_pos, rx338_off + substr $S10, rx338_tgt, $I11, 5 + ne $S10, "CATCH", rx338_fail + add rx338_pos, 5 + set_addr $I10, rxcap_342_fail + ($I12, $I11) = rx338_cur."!mark_peek"($I10) + rx338_cur."!cursor_pos"($I11) + ($P10) = rx338_cur."!cursor_start"() + $P10."!cursor_pass"(rx338_pos, "") + rx338_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_340_done - rxcap_340_fail: - goto rx336_fail - rxcap_340_done: + goto rxcap_342_done + rxcap_342_fail: + goto rx338_fail + rxcap_342_done: # rx charclass s - ge rx336_pos, rx336_eos, rx336_fail - sub $I10, rx336_pos, rx336_off - is_cclass $I11, 32, rx336_tgt, $I10 - unless $I11, rx336_fail - inc rx336_pos + ge rx338_pos, rx338_eos, rx338_fail + sub $I10, rx338_pos, rx338_off + is_cclass $I11, 32, rx338_tgt, $I10 + unless $I11, rx338_fail + inc rx338_pos # rx subrule "ws" subtype=method negate= - rx336_cur."!cursor_pos"(rx336_pos) - $P10 = rx336_cur."ws"() - unless $P10, rx336_fail - rx336_pos = $P10."pos"() -.annotate 'line', 189 + rx338_cur."!cursor_pos"(rx338_pos) + $P10 = rx338_cur."ws"() + unless $P10, rx338_fail + rx338_pos = $P10."pos"() +.annotate 'line', 190 # rx subrule "block" subtype=capture negate= - rx336_cur."!cursor_pos"(rx336_pos) - $P10 = rx336_cur."block"() - unless $P10, rx336_fail - rx336_cur."!mark_push"(0, -1, 0, $P10) + rx338_cur."!cursor_pos"(rx338_pos) + $P10 = rx338_cur."block"() + unless $P10, rx338_fail + rx338_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("block") - rx336_pos = $P10."pos"() + rx338_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx336_cur."!cursor_pos"(rx336_pos) - $P10 = rx336_cur."ws"() - unless $P10, rx336_fail - rx336_pos = $P10."pos"() -.annotate 'line', 187 + rx338_cur."!cursor_pos"(rx338_pos) + $P10 = rx338_cur."ws"() + unless $P10, rx338_fail + rx338_pos = $P10."pos"() +.annotate 'line', 188 # rx pass - rx336_cur."!cursor_pass"(rx336_pos, "statement_control:sym") - rx336_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx336_pos) - .return (rx336_cur) - rx336_fail: -.annotate 'line', 4 - (rx336_rep, rx336_pos, $I10, $P10) = rx336_cur."!mark_fail"(0) - lt rx336_pos, -1, rx336_done - eq rx336_pos, -1, rx336_fail + rx338_cur."!cursor_pass"(rx338_pos, "statement_control:sym") + rx338_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx338_pos) + .return (rx338_cur) + rx338_fail: +.annotate 'line', 4 + (rx338_rep, rx338_pos, $I10, $P10) = rx338_cur."!mark_fail"(0) + lt rx338_pos, -1, rx338_done + eq rx338_pos, -1, rx338_fail jump $I10 - rx336_done: - rx336_cur."!cursor_fail"() - rx336_cur."!cursor_debug"("FAIL ", "statement_control:sym") - .return (rx336_cur) + rx338_done: + rx338_cur."!cursor_fail"() + rx338_cur."!cursor_debug"("FAIL ", "statement_control:sym") + .return (rx338_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_control:sym" :subid("74_1275511697.61926") :method +.sub "!PREFIX__statement_control:sym" :subid("74_1275600007.84296") :method .annotate 'line', 4 - new $P338, "ResizablePMCArray" - push $P338, "CATCH" - .return ($P338) + new $P340, "ResizablePMCArray" + push $P340, "CATCH" + .return ($P340) .end .namespace ["NQP";"Grammar"] -.sub "statement_control:sym" :subid("75_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement_control:sym" :subid("75_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx344_tgt - .local int rx344_pos - .local int rx344_off - .local int rx344_eos - .local int rx344_rep - .local pmc rx344_cur - (rx344_cur, rx344_pos, rx344_tgt) = self."!cursor_start"() - rx344_cur."!cursor_debug"("START ", "statement_control:sym") - .lex unicode:"$\x{a2}", rx344_cur + .local string rx346_tgt + .local int rx346_pos + .local int rx346_off + .local int rx346_eos + .local int rx346_rep + .local pmc rx346_cur + (rx346_cur, rx346_pos, rx346_tgt) = self."!cursor_start"() + rx346_cur."!cursor_debug"("START ", "statement_control:sym") + .lex unicode:"$\x{a2}", rx346_cur .local pmc match .lex "$/", match - length rx344_eos, rx344_tgt - gt rx344_pos, rx344_eos, rx344_done - set rx344_off, 0 - lt rx344_pos, 2, rx344_start - sub rx344_off, rx344_pos, 1 - substr rx344_tgt, rx344_tgt, rx344_off - rx344_start: + length rx346_eos, rx346_tgt + gt rx346_pos, rx346_eos, rx346_done + set rx346_off, 0 + lt rx346_pos, 2, rx346_start + sub rx346_off, rx346_pos, 1 + substr rx346_tgt, rx346_tgt, rx346_off + rx346_start: $I10 = self.'from'() - ne $I10, -1, rxscan347_done - goto rxscan347_scan - rxscan347_loop: - ($P10) = rx344_cur."from"() + ne $I10, -1, rxscan349_done + goto rxscan349_scan + rxscan349_loop: + ($P10) = rx346_cur."from"() inc $P10 - set rx344_pos, $P10 - ge rx344_pos, rx344_eos, rxscan347_done - rxscan347_scan: - set_addr $I10, rxscan347_loop - rx344_cur."!mark_push"(0, rx344_pos, $I10) - rxscan347_done: -.annotate 'line', 193 + set rx346_pos, $P10 + ge rx346_pos, rx346_eos, rxscan349_done + rxscan349_scan: + set_addr $I10, rxscan349_loop + rx346_cur."!mark_push"(0, rx346_pos, $I10) + rxscan349_done: +.annotate 'line', 194 # rx subcapture "sym" - set_addr $I10, rxcap_348_fail - rx344_cur."!mark_push"(0, rx344_pos, $I10) + set_addr $I10, rxcap_350_fail + rx346_cur."!mark_push"(0, rx346_pos, $I10) # rx literal "CONTROL" - add $I11, rx344_pos, 7 - gt $I11, rx344_eos, rx344_fail - sub $I11, rx344_pos, rx344_off - substr $S10, rx344_tgt, $I11, 7 - ne $S10, "CONTROL", rx344_fail - add rx344_pos, 7 - set_addr $I10, rxcap_348_fail - ($I12, $I11) = rx344_cur."!mark_peek"($I10) - rx344_cur."!cursor_pos"($I11) - ($P10) = rx344_cur."!cursor_start"() - $P10."!cursor_pass"(rx344_pos, "") - rx344_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx346_pos, 7 + gt $I11, rx346_eos, rx346_fail + sub $I11, rx346_pos, rx346_off + substr $S10, rx346_tgt, $I11, 7 + ne $S10, "CONTROL", rx346_fail + add rx346_pos, 7 + set_addr $I10, rxcap_350_fail + ($I12, $I11) = rx346_cur."!mark_peek"($I10) + rx346_cur."!cursor_pos"($I11) + ($P10) = rx346_cur."!cursor_start"() + $P10."!cursor_pass"(rx346_pos, "") + rx346_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_348_done - rxcap_348_fail: - goto rx344_fail - rxcap_348_done: + goto rxcap_350_done + rxcap_350_fail: + goto rx346_fail + rxcap_350_done: # rx charclass s - ge rx344_pos, rx344_eos, rx344_fail - sub $I10, rx344_pos, rx344_off - is_cclass $I11, 32, rx344_tgt, $I10 - unless $I11, rx344_fail - inc rx344_pos + ge rx346_pos, rx346_eos, rx346_fail + sub $I10, rx346_pos, rx346_off + is_cclass $I11, 32, rx346_tgt, $I10 + unless $I11, rx346_fail + inc rx346_pos # rx subrule "ws" subtype=method negate= - rx344_cur."!cursor_pos"(rx344_pos) - $P10 = rx344_cur."ws"() - unless $P10, rx344_fail - rx344_pos = $P10."pos"() -.annotate 'line', 194 + rx346_cur."!cursor_pos"(rx346_pos) + $P10 = rx346_cur."ws"() + unless $P10, rx346_fail + rx346_pos = $P10."pos"() +.annotate 'line', 195 # rx subrule "block" subtype=capture negate= - rx344_cur."!cursor_pos"(rx344_pos) - $P10 = rx344_cur."block"() - unless $P10, rx344_fail - rx344_cur."!mark_push"(0, -1, 0, $P10) + rx346_cur."!cursor_pos"(rx346_pos) + $P10 = rx346_cur."block"() + unless $P10, rx346_fail + rx346_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("block") - rx344_pos = $P10."pos"() + rx346_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx344_cur."!cursor_pos"(rx344_pos) - $P10 = rx344_cur."ws"() - unless $P10, rx344_fail - rx344_pos = $P10."pos"() -.annotate 'line', 192 + rx346_cur."!cursor_pos"(rx346_pos) + $P10 = rx346_cur."ws"() + unless $P10, rx346_fail + rx346_pos = $P10."pos"() +.annotate 'line', 193 # rx pass - rx344_cur."!cursor_pass"(rx344_pos, "statement_control:sym") - rx344_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx344_pos) - .return (rx344_cur) - rx344_fail: -.annotate 'line', 4 - (rx344_rep, rx344_pos, $I10, $P10) = rx344_cur."!mark_fail"(0) - lt rx344_pos, -1, rx344_done - eq rx344_pos, -1, rx344_fail + rx346_cur."!cursor_pass"(rx346_pos, "statement_control:sym") + rx346_cur."!cursor_debug"("PASS ", "statement_control:sym", " at pos=", rx346_pos) + .return (rx346_cur) + rx346_fail: +.annotate 'line', 4 + (rx346_rep, rx346_pos, $I10, $P10) = rx346_cur."!mark_fail"(0) + lt rx346_pos, -1, rx346_done + eq rx346_pos, -1, rx346_fail jump $I10 - rx344_done: - rx344_cur."!cursor_fail"() - rx344_cur."!cursor_debug"("FAIL ", "statement_control:sym") - .return (rx344_cur) + rx346_done: + rx346_cur."!cursor_fail"() + rx346_cur."!cursor_debug"("FAIL ", "statement_control:sym") + .return (rx346_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_control:sym" :subid("76_1275511697.61926") :method +.sub "!PREFIX__statement_control:sym" :subid("76_1275600007.84296") :method .annotate 'line', 4 - new $P346, "ResizablePMCArray" - push $P346, "CONTROL" - .return ($P346) + new $P348, "ResizablePMCArray" + push $P348, "CONTROL" + .return ($P348) .end .namespace ["NQP";"Grammar"] -.sub "statement_prefix" :subid("77_1275511697.61926") :method -.annotate 'line', 197 - $P352 = self."!protoregex"("statement_prefix") - .return ($P352) +.sub "statement_prefix" :subid("77_1275600007.84296") :method +.annotate 'line', 198 + $P354 = self."!protoregex"("statement_prefix") + .return ($P354) .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_prefix" :subid("78_1275511697.61926") :method -.annotate 'line', 197 - $P354 = self."!PREFIX__!protoregex"("statement_prefix") - .return ($P354) +.sub "!PREFIX__statement_prefix" :subid("78_1275600007.84296") :method +.annotate 'line', 198 + $P356 = self."!PREFIX__!protoregex"("statement_prefix") + .return ($P356) .end .namespace ["NQP";"Grammar"] -.sub "statement_prefix:sym" :subid("79_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement_prefix:sym" :subid("79_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx356_tgt - .local int rx356_pos - .local int rx356_off - .local int rx356_eos - .local int rx356_rep - .local pmc rx356_cur - (rx356_cur, rx356_pos, rx356_tgt) = self."!cursor_start"() - rx356_cur."!cursor_debug"("START ", "statement_prefix:sym") - .lex unicode:"$\x{a2}", rx356_cur + .local string rx358_tgt + .local int rx358_pos + .local int rx358_off + .local int rx358_eos + .local int rx358_rep + .local pmc rx358_cur + (rx358_cur, rx358_pos, rx358_tgt) = self."!cursor_start"() + rx358_cur."!cursor_debug"("START ", "statement_prefix:sym") + .lex unicode:"$\x{a2}", rx358_cur .local pmc match .lex "$/", match - length rx356_eos, rx356_tgt - gt rx356_pos, rx356_eos, rx356_done - set rx356_off, 0 - lt rx356_pos, 2, rx356_start - sub rx356_off, rx356_pos, 1 - substr rx356_tgt, rx356_tgt, rx356_off - rx356_start: + length rx358_eos, rx358_tgt + gt rx358_pos, rx358_eos, rx358_done + set rx358_off, 0 + lt rx358_pos, 2, rx358_start + sub rx358_off, rx358_pos, 1 + substr rx358_tgt, rx358_tgt, rx358_off + rx358_start: $I10 = self.'from'() - ne $I10, -1, rxscan360_done - goto rxscan360_scan - rxscan360_loop: - ($P10) = rx356_cur."from"() + ne $I10, -1, rxscan362_done + goto rxscan362_scan + rxscan362_loop: + ($P10) = rx358_cur."from"() inc $P10 - set rx356_pos, $P10 - ge rx356_pos, rx356_eos, rxscan360_done - rxscan360_scan: - set_addr $I10, rxscan360_loop - rx356_cur."!mark_push"(0, rx356_pos, $I10) - rxscan360_done: -.annotate 'line', 198 + set rx358_pos, $P10 + ge rx358_pos, rx358_eos, rxscan362_done + rxscan362_scan: + set_addr $I10, rxscan362_loop + rx358_cur."!mark_push"(0, rx358_pos, $I10) + rxscan362_done: +.annotate 'line', 199 # rx subcapture "sym" - set_addr $I10, rxcap_361_fail - rx356_cur."!mark_push"(0, rx356_pos, $I10) + set_addr $I10, rxcap_363_fail + rx358_cur."!mark_push"(0, rx358_pos, $I10) # rx literal "INIT" - add $I11, rx356_pos, 4 - gt $I11, rx356_eos, rx356_fail - sub $I11, rx356_pos, rx356_off - substr $S10, rx356_tgt, $I11, 4 - ne $S10, "INIT", rx356_fail - add rx356_pos, 4 - set_addr $I10, rxcap_361_fail - ($I12, $I11) = rx356_cur."!mark_peek"($I10) - rx356_cur."!cursor_pos"($I11) - ($P10) = rx356_cur."!cursor_start"() - $P10."!cursor_pass"(rx356_pos, "") - rx356_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx358_pos, 4 + gt $I11, rx358_eos, rx358_fail + sub $I11, rx358_pos, rx358_off + substr $S10, rx358_tgt, $I11, 4 + ne $S10, "INIT", rx358_fail + add rx358_pos, 4 + set_addr $I10, rxcap_363_fail + ($I12, $I11) = rx358_cur."!mark_peek"($I10) + rx358_cur."!cursor_pos"($I11) + ($P10) = rx358_cur."!cursor_start"() + $P10."!cursor_pass"(rx358_pos, "") + rx358_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_361_done - rxcap_361_fail: - goto rx356_fail - rxcap_361_done: + goto rxcap_363_done + rxcap_363_fail: + goto rx358_fail + rxcap_363_done: # rx subrule "blorst" subtype=capture negate= - rx356_cur."!cursor_pos"(rx356_pos) - $P10 = rx356_cur."blorst"() - unless $P10, rx356_fail - rx356_cur."!mark_push"(0, -1, 0, $P10) + rx358_cur."!cursor_pos"(rx358_pos) + $P10 = rx358_cur."blorst"() + unless $P10, rx358_fail + rx358_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("blorst") - rx356_pos = $P10."pos"() + rx358_pos = $P10."pos"() # rx pass - rx356_cur."!cursor_pass"(rx356_pos, "statement_prefix:sym") - rx356_cur."!cursor_debug"("PASS ", "statement_prefix:sym", " at pos=", rx356_pos) - .return (rx356_cur) - rx356_fail: -.annotate 'line', 4 - (rx356_rep, rx356_pos, $I10, $P10) = rx356_cur."!mark_fail"(0) - lt rx356_pos, -1, rx356_done - eq rx356_pos, -1, rx356_fail + rx358_cur."!cursor_pass"(rx358_pos, "statement_prefix:sym") + rx358_cur."!cursor_debug"("PASS ", "statement_prefix:sym", " at pos=", rx358_pos) + .return (rx358_cur) + rx358_fail: +.annotate 'line', 4 + (rx358_rep, rx358_pos, $I10, $P10) = rx358_cur."!mark_fail"(0) + lt rx358_pos, -1, rx358_done + eq rx358_pos, -1, rx358_fail jump $I10 - rx356_done: - rx356_cur."!cursor_fail"() - rx356_cur."!cursor_debug"("FAIL ", "statement_prefix:sym") - .return (rx356_cur) + rx358_done: + rx358_cur."!cursor_fail"() + rx358_cur."!cursor_debug"("FAIL ", "statement_prefix:sym") + .return (rx358_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_prefix:sym" :subid("80_1275511697.61926") :method +.sub "!PREFIX__statement_prefix:sym" :subid("80_1275600007.84296") :method .annotate 'line', 4 - $P358 = self."!PREFIX__!subrule"("blorst", "INIT") - new $P359, "ResizablePMCArray" - push $P359, $P358 - .return ($P359) + $P360 = self."!PREFIX__!subrule"("blorst", "INIT") + new $P361, "ResizablePMCArray" + push $P361, $P360 + .return ($P361) .end .namespace ["NQP";"Grammar"] -.sub "statement_prefix:sym" :subid("81_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement_prefix:sym" :subid("81_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx363_tgt - .local int rx363_pos - .local int rx363_off - .local int rx363_eos - .local int rx363_rep - .local pmc rx363_cur - (rx363_cur, rx363_pos, rx363_tgt) = self."!cursor_start"() - rx363_cur."!cursor_debug"("START ", "statement_prefix:sym") - .lex unicode:"$\x{a2}", rx363_cur + .local string rx365_tgt + .local int rx365_pos + .local int rx365_off + .local int rx365_eos + .local int rx365_rep + .local pmc rx365_cur + (rx365_cur, rx365_pos, rx365_tgt) = self."!cursor_start"() + rx365_cur."!cursor_debug"("START ", "statement_prefix:sym") + .lex unicode:"$\x{a2}", rx365_cur .local pmc match .lex "$/", match - length rx363_eos, rx363_tgt - gt rx363_pos, rx363_eos, rx363_done - set rx363_off, 0 - lt rx363_pos, 2, rx363_start - sub rx363_off, rx363_pos, 1 - substr rx363_tgt, rx363_tgt, rx363_off - rx363_start: + length rx365_eos, rx365_tgt + gt rx365_pos, rx365_eos, rx365_done + set rx365_off, 0 + lt rx365_pos, 2, rx365_start + sub rx365_off, rx365_pos, 1 + substr rx365_tgt, rx365_tgt, rx365_off + rx365_start: $I10 = self.'from'() - ne $I10, -1, rxscan367_done - goto rxscan367_scan - rxscan367_loop: - ($P10) = rx363_cur."from"() + ne $I10, -1, rxscan369_done + goto rxscan369_scan + rxscan369_loop: + ($P10) = rx365_cur."from"() inc $P10 - set rx363_pos, $P10 - ge rx363_pos, rx363_eos, rxscan367_done - rxscan367_scan: - set_addr $I10, rxscan367_loop - rx363_cur."!mark_push"(0, rx363_pos, $I10) - rxscan367_done: -.annotate 'line', 201 + set rx365_pos, $P10 + ge rx365_pos, rx365_eos, rxscan369_done + rxscan369_scan: + set_addr $I10, rxscan369_loop + rx365_cur."!mark_push"(0, rx365_pos, $I10) + rxscan369_done: +.annotate 'line', 202 # rx subcapture "sym" - set_addr $I10, rxcap_368_fail - rx363_cur."!mark_push"(0, rx363_pos, $I10) + set_addr $I10, rxcap_370_fail + rx365_cur."!mark_push"(0, rx365_pos, $I10) # rx literal "try" - add $I11, rx363_pos, 3 - gt $I11, rx363_eos, rx363_fail - sub $I11, rx363_pos, rx363_off - substr $S10, rx363_tgt, $I11, 3 - ne $S10, "try", rx363_fail - add rx363_pos, 3 - set_addr $I10, rxcap_368_fail - ($I12, $I11) = rx363_cur."!mark_peek"($I10) - rx363_cur."!cursor_pos"($I11) - ($P10) = rx363_cur."!cursor_start"() - $P10."!cursor_pass"(rx363_pos, "") - rx363_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx365_pos, 3 + gt $I11, rx365_eos, rx365_fail + sub $I11, rx365_pos, rx365_off + substr $S10, rx365_tgt, $I11, 3 + ne $S10, "try", rx365_fail + add rx365_pos, 3 + set_addr $I10, rxcap_370_fail + ($I12, $I11) = rx365_cur."!mark_peek"($I10) + rx365_cur."!cursor_pos"($I11) + ($P10) = rx365_cur."!cursor_start"() + $P10."!cursor_pass"(rx365_pos, "") + rx365_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_368_done - rxcap_368_fail: - goto rx363_fail - rxcap_368_done: -.annotate 'line', 202 + goto rxcap_370_done + rxcap_370_fail: + goto rx365_fail + rxcap_370_done: +.annotate 'line', 203 # rx subrule "blorst" subtype=capture negate= - rx363_cur."!cursor_pos"(rx363_pos) - $P10 = rx363_cur."blorst"() - unless $P10, rx363_fail - rx363_cur."!mark_push"(0, -1, 0, $P10) + rx365_cur."!cursor_pos"(rx365_pos) + $P10 = rx365_cur."blorst"() + unless $P10, rx365_fail + rx365_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("blorst") - rx363_pos = $P10."pos"() -.annotate 'line', 200 + rx365_pos = $P10."pos"() +.annotate 'line', 201 # rx pass - rx363_cur."!cursor_pass"(rx363_pos, "statement_prefix:sym") - rx363_cur."!cursor_debug"("PASS ", "statement_prefix:sym", " at pos=", rx363_pos) - .return (rx363_cur) - rx363_fail: -.annotate 'line', 4 - (rx363_rep, rx363_pos, $I10, $P10) = rx363_cur."!mark_fail"(0) - lt rx363_pos, -1, rx363_done - eq rx363_pos, -1, rx363_fail + rx365_cur."!cursor_pass"(rx365_pos, "statement_prefix:sym") + rx365_cur."!cursor_debug"("PASS ", "statement_prefix:sym", " at pos=", rx365_pos) + .return (rx365_cur) + rx365_fail: +.annotate 'line', 4 + (rx365_rep, rx365_pos, $I10, $P10) = rx365_cur."!mark_fail"(0) + lt rx365_pos, -1, rx365_done + eq rx365_pos, -1, rx365_fail jump $I10 - rx363_done: - rx363_cur."!cursor_fail"() - rx363_cur."!cursor_debug"("FAIL ", "statement_prefix:sym") - .return (rx363_cur) + rx365_done: + rx365_cur."!cursor_fail"() + rx365_cur."!cursor_debug"("FAIL ", "statement_prefix:sym") + .return (rx365_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_prefix:sym" :subid("82_1275511697.61926") :method +.sub "!PREFIX__statement_prefix:sym" :subid("82_1275600007.84296") :method .annotate 'line', 4 - $P365 = self."!PREFIX__!subrule"("blorst", "try") - new $P366, "ResizablePMCArray" - push $P366, $P365 - .return ($P366) + $P367 = self."!PREFIX__!subrule"("blorst", "try") + new $P368, "ResizablePMCArray" + push $P368, $P367 + .return ($P368) .end .namespace ["NQP";"Grammar"] -.sub "blorst" :subid("83_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "blorst" :subid("83_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx370_tgt - .local int rx370_pos - .local int rx370_off - .local int rx370_eos - .local int rx370_rep - .local pmc rx370_cur - (rx370_cur, rx370_pos, rx370_tgt) = self."!cursor_start"() - rx370_cur."!cursor_debug"("START ", "blorst") - .lex unicode:"$\x{a2}", rx370_cur + .local string rx372_tgt + .local int rx372_pos + .local int rx372_off + .local int rx372_eos + .local int rx372_rep + .local pmc rx372_cur + (rx372_cur, rx372_pos, rx372_tgt) = self."!cursor_start"() + rx372_cur."!cursor_debug"("START ", "blorst") + .lex unicode:"$\x{a2}", rx372_cur .local pmc match .lex "$/", match - length rx370_eos, rx370_tgt - gt rx370_pos, rx370_eos, rx370_done - set rx370_off, 0 - lt rx370_pos, 2, rx370_start - sub rx370_off, rx370_pos, 1 - substr rx370_tgt, rx370_tgt, rx370_off - rx370_start: + length rx372_eos, rx372_tgt + gt rx372_pos, rx372_eos, rx372_done + set rx372_off, 0 + lt rx372_pos, 2, rx372_start + sub rx372_off, rx372_pos, 1 + substr rx372_tgt, rx372_tgt, rx372_off + rx372_start: $I10 = self.'from'() - ne $I10, -1, rxscan373_done - goto rxscan373_scan - rxscan373_loop: - ($P10) = rx370_cur."from"() + ne $I10, -1, rxscan375_done + goto rxscan375_scan + rxscan375_loop: + ($P10) = rx372_cur."from"() inc $P10 - set rx370_pos, $P10 - ge rx370_pos, rx370_eos, rxscan373_done - rxscan373_scan: - set_addr $I10, rxscan373_loop - rx370_cur."!mark_push"(0, rx370_pos, $I10) - rxscan373_done: -.annotate 'line', 206 + set rx372_pos, $P10 + ge rx372_pos, rx372_eos, rxscan375_done + rxscan375_scan: + set_addr $I10, rxscan375_loop + rx372_cur."!mark_push"(0, rx372_pos, $I10) + rxscan375_done: +.annotate 'line', 207 # rx charclass s - ge rx370_pos, rx370_eos, rx370_fail - sub $I10, rx370_pos, rx370_off - is_cclass $I11, 32, rx370_tgt, $I10 - unless $I11, rx370_fail - inc rx370_pos + ge rx372_pos, rx372_eos, rx372_fail + sub $I10, rx372_pos, rx372_off + is_cclass $I11, 32, rx372_tgt, $I10 + unless $I11, rx372_fail + inc rx372_pos # rx subrule "ws" subtype=method negate= - rx370_cur."!cursor_pos"(rx370_pos) - $P10 = rx370_cur."ws"() - unless $P10, rx370_fail - rx370_pos = $P10."pos"() - alt374_0: - set_addr $I10, alt374_1 - rx370_cur."!mark_push"(0, rx370_pos, $I10) + rx372_cur."!cursor_pos"(rx372_pos) + $P10 = rx372_cur."ws"() + unless $P10, rx372_fail + rx372_pos = $P10."pos"() + alt376_0: + set_addr $I10, alt376_1 + rx372_cur."!mark_push"(0, rx372_pos, $I10) # rx enumcharlist negate=0 zerowidth - ge rx370_pos, rx370_eos, rx370_fail - sub $I10, rx370_pos, rx370_off - substr $S10, rx370_tgt, $I10, 1 + ge rx372_pos, rx372_eos, rx372_fail + sub $I10, rx372_pos, rx372_off + substr $S10, rx372_tgt, $I10, 1 index $I11, "{", $S10 - lt $I11, 0, rx370_fail + lt $I11, 0, rx372_fail # rx subrule "block" subtype=capture negate= - rx370_cur."!cursor_pos"(rx370_pos) - $P10 = rx370_cur."block"() - unless $P10, rx370_fail - rx370_cur."!mark_push"(0, -1, 0, $P10) + rx372_cur."!cursor_pos"(rx372_pos) + $P10 = rx372_cur."block"() + unless $P10, rx372_fail + rx372_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("block") - rx370_pos = $P10."pos"() - goto alt374_end - alt374_1: + rx372_pos = $P10."pos"() + goto alt376_end + alt376_1: # rx subrule "statement" subtype=capture negate= - rx370_cur."!cursor_pos"(rx370_pos) - $P10 = rx370_cur."statement"() - unless $P10, rx370_fail - rx370_cur."!mark_push"(0, -1, 0, $P10) + rx372_cur."!cursor_pos"(rx372_pos) + $P10 = rx372_cur."statement"() + unless $P10, rx372_fail + rx372_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("statement") - rx370_pos = $P10."pos"() - alt374_end: -.annotate 'line', 205 + rx372_pos = $P10."pos"() + alt376_end: +.annotate 'line', 206 # rx pass - rx370_cur."!cursor_pass"(rx370_pos, "blorst") - rx370_cur."!cursor_debug"("PASS ", "blorst", " at pos=", rx370_pos) - .return (rx370_cur) - rx370_fail: -.annotate 'line', 4 - (rx370_rep, rx370_pos, $I10, $P10) = rx370_cur."!mark_fail"(0) - lt rx370_pos, -1, rx370_done - eq rx370_pos, -1, rx370_fail + rx372_cur."!cursor_pass"(rx372_pos, "blorst") + rx372_cur."!cursor_debug"("PASS ", "blorst", " at pos=", rx372_pos) + .return (rx372_cur) + rx372_fail: +.annotate 'line', 4 + (rx372_rep, rx372_pos, $I10, $P10) = rx372_cur."!mark_fail"(0) + lt rx372_pos, -1, rx372_done + eq rx372_pos, -1, rx372_fail jump $I10 - rx370_done: - rx370_cur."!cursor_fail"() - rx370_cur."!cursor_debug"("FAIL ", "blorst") - .return (rx370_cur) + rx372_done: + rx372_cur."!cursor_fail"() + rx372_cur."!cursor_debug"("FAIL ", "blorst") + .return (rx372_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__blorst" :subid("84_1275511697.61926") :method +.sub "!PREFIX__blorst" :subid("84_1275600007.84296") :method .annotate 'line', 4 - new $P372, "ResizablePMCArray" - push $P372, "" - .return ($P372) + new $P374, "ResizablePMCArray" + push $P374, "" + .return ($P374) .end .namespace ["NQP";"Grammar"] -.sub "statement_mod_cond" :subid("85_1275511697.61926") :method -.annotate 'line', 211 - $P376 = self."!protoregex"("statement_mod_cond") - .return ($P376) +.sub "statement_mod_cond" :subid("85_1275600007.84296") :method +.annotate 'line', 212 + $P378 = self."!protoregex"("statement_mod_cond") + .return ($P378) .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_mod_cond" :subid("86_1275511697.61926") :method -.annotate 'line', 211 - $P378 = self."!PREFIX__!protoregex"("statement_mod_cond") - .return ($P378) +.sub "!PREFIX__statement_mod_cond" :subid("86_1275600007.84296") :method +.annotate 'line', 212 + $P380 = self."!PREFIX__!protoregex"("statement_mod_cond") + .return ($P380) .end .namespace ["NQP";"Grammar"] -.sub "statement_mod_cond:sym" :subid("87_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement_mod_cond:sym" :subid("87_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx380_tgt - .local int rx380_pos - .local int rx380_off - .local int rx380_eos - .local int rx380_rep - .local pmc rx380_cur - (rx380_cur, rx380_pos, rx380_tgt) = self."!cursor_start"() - rx380_cur."!cursor_debug"("START ", "statement_mod_cond:sym") - .lex unicode:"$\x{a2}", rx380_cur + .local string rx382_tgt + .local int rx382_pos + .local int rx382_off + .local int rx382_eos + .local int rx382_rep + .local pmc rx382_cur + (rx382_cur, rx382_pos, rx382_tgt) = self."!cursor_start"() + rx382_cur."!cursor_debug"("START ", "statement_mod_cond:sym") + .lex unicode:"$\x{a2}", rx382_cur .local pmc match .lex "$/", match - length rx380_eos, rx380_tgt - gt rx380_pos, rx380_eos, rx380_done - set rx380_off, 0 - lt rx380_pos, 2, rx380_start - sub rx380_off, rx380_pos, 1 - substr rx380_tgt, rx380_tgt, rx380_off - rx380_start: + length rx382_eos, rx382_tgt + gt rx382_pos, rx382_eos, rx382_done + set rx382_off, 0 + lt rx382_pos, 2, rx382_start + sub rx382_off, rx382_pos, 1 + substr rx382_tgt, rx382_tgt, rx382_off + rx382_start: $I10 = self.'from'() - ne $I10, -1, rxscan383_done - goto rxscan383_scan - rxscan383_loop: - ($P10) = rx380_cur."from"() + ne $I10, -1, rxscan385_done + goto rxscan385_scan + rxscan385_loop: + ($P10) = rx382_cur."from"() inc $P10 - set rx380_pos, $P10 - ge rx380_pos, rx380_eos, rxscan383_done - rxscan383_scan: - set_addr $I10, rxscan383_loop - rx380_cur."!mark_push"(0, rx380_pos, $I10) - rxscan383_done: -.annotate 'line', 213 + set rx382_pos, $P10 + ge rx382_pos, rx382_eos, rxscan385_done + rxscan385_scan: + set_addr $I10, rxscan385_loop + rx382_cur."!mark_push"(0, rx382_pos, $I10) + rxscan385_done: +.annotate 'line', 214 # rx subcapture "sym" - set_addr $I10, rxcap_384_fail - rx380_cur."!mark_push"(0, rx380_pos, $I10) + set_addr $I10, rxcap_386_fail + rx382_cur."!mark_push"(0, rx382_pos, $I10) # rx literal "if" - add $I11, rx380_pos, 2 - gt $I11, rx380_eos, rx380_fail - sub $I11, rx380_pos, rx380_off - substr $S10, rx380_tgt, $I11, 2 - ne $S10, "if", rx380_fail - add rx380_pos, 2 - set_addr $I10, rxcap_384_fail - ($I12, $I11) = rx380_cur."!mark_peek"($I10) - rx380_cur."!cursor_pos"($I11) - ($P10) = rx380_cur."!cursor_start"() - $P10."!cursor_pass"(rx380_pos, "") - rx380_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx382_pos, 2 + gt $I11, rx382_eos, rx382_fail + sub $I11, rx382_pos, rx382_off + substr $S10, rx382_tgt, $I11, 2 + ne $S10, "if", rx382_fail + add rx382_pos, 2 + set_addr $I10, rxcap_386_fail + ($I12, $I11) = rx382_cur."!mark_peek"($I10) + rx382_cur."!cursor_pos"($I11) + ($P10) = rx382_cur."!cursor_start"() + $P10."!cursor_pass"(rx382_pos, "") + rx382_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_384_done - rxcap_384_fail: - goto rx380_fail - rxcap_384_done: + goto rxcap_386_done + rxcap_386_fail: + goto rx382_fail + rxcap_386_done: # rx subrule "ws" subtype=method negate= - rx380_cur."!cursor_pos"(rx380_pos) - $P10 = rx380_cur."ws"() - unless $P10, rx380_fail - rx380_pos = $P10."pos"() + rx382_cur."!cursor_pos"(rx382_pos) + $P10 = rx382_cur."ws"() + unless $P10, rx382_fail + rx382_pos = $P10."pos"() # rx subrule "EXPR" subtype=capture negate= - rx380_cur."!cursor_pos"(rx380_pos) - $P10 = rx380_cur."EXPR"() - unless $P10, rx380_fail - rx380_cur."!mark_push"(0, -1, 0, $P10) + rx382_cur."!cursor_pos"(rx382_pos) + $P10 = rx382_cur."EXPR"() + unless $P10, rx382_fail + rx382_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("cond") - rx380_pos = $P10."pos"() + rx382_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx380_cur."!cursor_pos"(rx380_pos) - $P10 = rx380_cur."ws"() - unless $P10, rx380_fail - rx380_pos = $P10."pos"() + rx382_cur."!cursor_pos"(rx382_pos) + $P10 = rx382_cur."ws"() + unless $P10, rx382_fail + rx382_pos = $P10."pos"() # rx pass - rx380_cur."!cursor_pass"(rx380_pos, "statement_mod_cond:sym") - rx380_cur."!cursor_debug"("PASS ", "statement_mod_cond:sym", " at pos=", rx380_pos) - .return (rx380_cur) - rx380_fail: -.annotate 'line', 4 - (rx380_rep, rx380_pos, $I10, $P10) = rx380_cur."!mark_fail"(0) - lt rx380_pos, -1, rx380_done - eq rx380_pos, -1, rx380_fail + rx382_cur."!cursor_pass"(rx382_pos, "statement_mod_cond:sym") + rx382_cur."!cursor_debug"("PASS ", "statement_mod_cond:sym", " at pos=", rx382_pos) + .return (rx382_cur) + rx382_fail: +.annotate 'line', 4 + (rx382_rep, rx382_pos, $I10, $P10) = rx382_cur."!mark_fail"(0) + lt rx382_pos, -1, rx382_done + eq rx382_pos, -1, rx382_fail jump $I10 - rx380_done: - rx380_cur."!cursor_fail"() - rx380_cur."!cursor_debug"("FAIL ", "statement_mod_cond:sym") - .return (rx380_cur) + rx382_done: + rx382_cur."!cursor_fail"() + rx382_cur."!cursor_debug"("FAIL ", "statement_mod_cond:sym") + .return (rx382_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_mod_cond:sym" :subid("88_1275511697.61926") :method +.sub "!PREFIX__statement_mod_cond:sym" :subid("88_1275600007.84296") :method .annotate 'line', 4 - new $P382, "ResizablePMCArray" - push $P382, "if" - .return ($P382) + new $P384, "ResizablePMCArray" + push $P384, "if" + .return ($P384) .end .namespace ["NQP";"Grammar"] -.sub "statement_mod_cond:sym" :subid("89_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement_mod_cond:sym" :subid("89_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx388_tgt - .local int rx388_pos - .local int rx388_off - .local int rx388_eos - .local int rx388_rep - .local pmc rx388_cur - (rx388_cur, rx388_pos, rx388_tgt) = self."!cursor_start"() - rx388_cur."!cursor_debug"("START ", "statement_mod_cond:sym") - .lex unicode:"$\x{a2}", rx388_cur + .local string rx390_tgt + .local int rx390_pos + .local int rx390_off + .local int rx390_eos + .local int rx390_rep + .local pmc rx390_cur + (rx390_cur, rx390_pos, rx390_tgt) = self."!cursor_start"() + rx390_cur."!cursor_debug"("START ", "statement_mod_cond:sym") + .lex unicode:"$\x{a2}", rx390_cur .local pmc match .lex "$/", match - length rx388_eos, rx388_tgt - gt rx388_pos, rx388_eos, rx388_done - set rx388_off, 0 - lt rx388_pos, 2, rx388_start - sub rx388_off, rx388_pos, 1 - substr rx388_tgt, rx388_tgt, rx388_off - rx388_start: + length rx390_eos, rx390_tgt + gt rx390_pos, rx390_eos, rx390_done + set rx390_off, 0 + lt rx390_pos, 2, rx390_start + sub rx390_off, rx390_pos, 1 + substr rx390_tgt, rx390_tgt, rx390_off + rx390_start: $I10 = self.'from'() - ne $I10, -1, rxscan391_done - goto rxscan391_scan - rxscan391_loop: - ($P10) = rx388_cur."from"() + ne $I10, -1, rxscan393_done + goto rxscan393_scan + rxscan393_loop: + ($P10) = rx390_cur."from"() inc $P10 - set rx388_pos, $P10 - ge rx388_pos, rx388_eos, rxscan391_done - rxscan391_scan: - set_addr $I10, rxscan391_loop - rx388_cur."!mark_push"(0, rx388_pos, $I10) - rxscan391_done: -.annotate 'line', 214 + set rx390_pos, $P10 + ge rx390_pos, rx390_eos, rxscan393_done + rxscan393_scan: + set_addr $I10, rxscan393_loop + rx390_cur."!mark_push"(0, rx390_pos, $I10) + rxscan393_done: +.annotate 'line', 215 # rx subcapture "sym" - set_addr $I10, rxcap_392_fail - rx388_cur."!mark_push"(0, rx388_pos, $I10) + set_addr $I10, rxcap_394_fail + rx390_cur."!mark_push"(0, rx390_pos, $I10) # rx literal "unless" - add $I11, rx388_pos, 6 - gt $I11, rx388_eos, rx388_fail - sub $I11, rx388_pos, rx388_off - substr $S10, rx388_tgt, $I11, 6 - ne $S10, "unless", rx388_fail - add rx388_pos, 6 - set_addr $I10, rxcap_392_fail - ($I12, $I11) = rx388_cur."!mark_peek"($I10) - rx388_cur."!cursor_pos"($I11) - ($P10) = rx388_cur."!cursor_start"() - $P10."!cursor_pass"(rx388_pos, "") - rx388_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx390_pos, 6 + gt $I11, rx390_eos, rx390_fail + sub $I11, rx390_pos, rx390_off + substr $S10, rx390_tgt, $I11, 6 + ne $S10, "unless", rx390_fail + add rx390_pos, 6 + set_addr $I10, rxcap_394_fail + ($I12, $I11) = rx390_cur."!mark_peek"($I10) + rx390_cur."!cursor_pos"($I11) + ($P10) = rx390_cur."!cursor_start"() + $P10."!cursor_pass"(rx390_pos, "") + rx390_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_392_done - rxcap_392_fail: - goto rx388_fail - rxcap_392_done: + goto rxcap_394_done + rxcap_394_fail: + goto rx390_fail + rxcap_394_done: # rx subrule "ws" subtype=method negate= - rx388_cur."!cursor_pos"(rx388_pos) - $P10 = rx388_cur."ws"() - unless $P10, rx388_fail - rx388_pos = $P10."pos"() + rx390_cur."!cursor_pos"(rx390_pos) + $P10 = rx390_cur."ws"() + unless $P10, rx390_fail + rx390_pos = $P10."pos"() # rx subrule "EXPR" subtype=capture negate= - rx388_cur."!cursor_pos"(rx388_pos) - $P10 = rx388_cur."EXPR"() - unless $P10, rx388_fail - rx388_cur."!mark_push"(0, -1, 0, $P10) + rx390_cur."!cursor_pos"(rx390_pos) + $P10 = rx390_cur."EXPR"() + unless $P10, rx390_fail + rx390_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("cond") - rx388_pos = $P10."pos"() + rx390_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx388_cur."!cursor_pos"(rx388_pos) - $P10 = rx388_cur."ws"() - unless $P10, rx388_fail - rx388_pos = $P10."pos"() + rx390_cur."!cursor_pos"(rx390_pos) + $P10 = rx390_cur."ws"() + unless $P10, rx390_fail + rx390_pos = $P10."pos"() # rx pass - rx388_cur."!cursor_pass"(rx388_pos, "statement_mod_cond:sym") - rx388_cur."!cursor_debug"("PASS ", "statement_mod_cond:sym", " at pos=", rx388_pos) - .return (rx388_cur) - rx388_fail: -.annotate 'line', 4 - (rx388_rep, rx388_pos, $I10, $P10) = rx388_cur."!mark_fail"(0) - lt rx388_pos, -1, rx388_done - eq rx388_pos, -1, rx388_fail + rx390_cur."!cursor_pass"(rx390_pos, "statement_mod_cond:sym") + rx390_cur."!cursor_debug"("PASS ", "statement_mod_cond:sym", " at pos=", rx390_pos) + .return (rx390_cur) + rx390_fail: +.annotate 'line', 4 + (rx390_rep, rx390_pos, $I10, $P10) = rx390_cur."!mark_fail"(0) + lt rx390_pos, -1, rx390_done + eq rx390_pos, -1, rx390_fail jump $I10 - rx388_done: - rx388_cur."!cursor_fail"() - rx388_cur."!cursor_debug"("FAIL ", "statement_mod_cond:sym") - .return (rx388_cur) + rx390_done: + rx390_cur."!cursor_fail"() + rx390_cur."!cursor_debug"("FAIL ", "statement_mod_cond:sym") + .return (rx390_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_mod_cond:sym" :subid("90_1275511697.61926") :method +.sub "!PREFIX__statement_mod_cond:sym" :subid("90_1275600007.84296") :method .annotate 'line', 4 - new $P390, "ResizablePMCArray" - push $P390, "unless" - .return ($P390) + new $P392, "ResizablePMCArray" + push $P392, "unless" + .return ($P392) .end .namespace ["NQP";"Grammar"] -.sub "statement_mod_loop" :subid("91_1275511697.61926") :method -.annotate 'line', 216 - $P396 = self."!protoregex"("statement_mod_loop") - .return ($P396) +.sub "statement_mod_loop" :subid("91_1275600007.84296") :method +.annotate 'line', 217 + $P398 = self."!protoregex"("statement_mod_loop") + .return ($P398) .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_mod_loop" :subid("92_1275511697.61926") :method -.annotate 'line', 216 - $P398 = self."!PREFIX__!protoregex"("statement_mod_loop") - .return ($P398) +.sub "!PREFIX__statement_mod_loop" :subid("92_1275600007.84296") :method +.annotate 'line', 217 + $P400 = self."!PREFIX__!protoregex"("statement_mod_loop") + .return ($P400) .end .namespace ["NQP";"Grammar"] -.sub "statement_mod_loop:sym" :subid("93_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement_mod_loop:sym" :subid("93_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx400_tgt - .local int rx400_pos - .local int rx400_off - .local int rx400_eos - .local int rx400_rep - .local pmc rx400_cur - (rx400_cur, rx400_pos, rx400_tgt) = self."!cursor_start"() - rx400_cur."!cursor_debug"("START ", "statement_mod_loop:sym") - .lex unicode:"$\x{a2}", rx400_cur + .local string rx402_tgt + .local int rx402_pos + .local int rx402_off + .local int rx402_eos + .local int rx402_rep + .local pmc rx402_cur + (rx402_cur, rx402_pos, rx402_tgt) = self."!cursor_start"() + rx402_cur."!cursor_debug"("START ", "statement_mod_loop:sym") + .lex unicode:"$\x{a2}", rx402_cur .local pmc match .lex "$/", match - length rx400_eos, rx400_tgt - gt rx400_pos, rx400_eos, rx400_done - set rx400_off, 0 - lt rx400_pos, 2, rx400_start - sub rx400_off, rx400_pos, 1 - substr rx400_tgt, rx400_tgt, rx400_off - rx400_start: + length rx402_eos, rx402_tgt + gt rx402_pos, rx402_eos, rx402_done + set rx402_off, 0 + lt rx402_pos, 2, rx402_start + sub rx402_off, rx402_pos, 1 + substr rx402_tgt, rx402_tgt, rx402_off + rx402_start: $I10 = self.'from'() - ne $I10, -1, rxscan403_done - goto rxscan403_scan - rxscan403_loop: - ($P10) = rx400_cur."from"() + ne $I10, -1, rxscan405_done + goto rxscan405_scan + rxscan405_loop: + ($P10) = rx402_cur."from"() inc $P10 - set rx400_pos, $P10 - ge rx400_pos, rx400_eos, rxscan403_done - rxscan403_scan: - set_addr $I10, rxscan403_loop - rx400_cur."!mark_push"(0, rx400_pos, $I10) - rxscan403_done: -.annotate 'line', 218 + set rx402_pos, $P10 + ge rx402_pos, rx402_eos, rxscan405_done + rxscan405_scan: + set_addr $I10, rxscan405_loop + rx402_cur."!mark_push"(0, rx402_pos, $I10) + rxscan405_done: +.annotate 'line', 219 # rx subcapture "sym" - set_addr $I10, rxcap_404_fail - rx400_cur."!mark_push"(0, rx400_pos, $I10) + set_addr $I10, rxcap_406_fail + rx402_cur."!mark_push"(0, rx402_pos, $I10) # rx literal "while" - add $I11, rx400_pos, 5 - gt $I11, rx400_eos, rx400_fail - sub $I11, rx400_pos, rx400_off - substr $S10, rx400_tgt, $I11, 5 - ne $S10, "while", rx400_fail - add rx400_pos, 5 - set_addr $I10, rxcap_404_fail - ($I12, $I11) = rx400_cur."!mark_peek"($I10) - rx400_cur."!cursor_pos"($I11) - ($P10) = rx400_cur."!cursor_start"() - $P10."!cursor_pass"(rx400_pos, "") - rx400_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx402_pos, 5 + gt $I11, rx402_eos, rx402_fail + sub $I11, rx402_pos, rx402_off + substr $S10, rx402_tgt, $I11, 5 + ne $S10, "while", rx402_fail + add rx402_pos, 5 + set_addr $I10, rxcap_406_fail + ($I12, $I11) = rx402_cur."!mark_peek"($I10) + rx402_cur."!cursor_pos"($I11) + ($P10) = rx402_cur."!cursor_start"() + $P10."!cursor_pass"(rx402_pos, "") + rx402_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_404_done - rxcap_404_fail: - goto rx400_fail - rxcap_404_done: + goto rxcap_406_done + rxcap_406_fail: + goto rx402_fail + rxcap_406_done: # rx subrule "ws" subtype=method negate= - rx400_cur."!cursor_pos"(rx400_pos) - $P10 = rx400_cur."ws"() - unless $P10, rx400_fail - rx400_pos = $P10."pos"() + rx402_cur."!cursor_pos"(rx402_pos) + $P10 = rx402_cur."ws"() + unless $P10, rx402_fail + rx402_pos = $P10."pos"() # rx subrule "EXPR" subtype=capture negate= - rx400_cur."!cursor_pos"(rx400_pos) - $P10 = rx400_cur."EXPR"() - unless $P10, rx400_fail - rx400_cur."!mark_push"(0, -1, 0, $P10) + rx402_cur."!cursor_pos"(rx402_pos) + $P10 = rx402_cur."EXPR"() + unless $P10, rx402_fail + rx402_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("cond") - rx400_pos = $P10."pos"() + rx402_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx400_cur."!cursor_pos"(rx400_pos) - $P10 = rx400_cur."ws"() - unless $P10, rx400_fail - rx400_pos = $P10."pos"() + rx402_cur."!cursor_pos"(rx402_pos) + $P10 = rx402_cur."ws"() + unless $P10, rx402_fail + rx402_pos = $P10."pos"() # rx pass - rx400_cur."!cursor_pass"(rx400_pos, "statement_mod_loop:sym") - rx400_cur."!cursor_debug"("PASS ", "statement_mod_loop:sym", " at pos=", rx400_pos) - .return (rx400_cur) - rx400_fail: -.annotate 'line', 4 - (rx400_rep, rx400_pos, $I10, $P10) = rx400_cur."!mark_fail"(0) - lt rx400_pos, -1, rx400_done - eq rx400_pos, -1, rx400_fail + rx402_cur."!cursor_pass"(rx402_pos, "statement_mod_loop:sym") + rx402_cur."!cursor_debug"("PASS ", "statement_mod_loop:sym", " at pos=", rx402_pos) + .return (rx402_cur) + rx402_fail: +.annotate 'line', 4 + (rx402_rep, rx402_pos, $I10, $P10) = rx402_cur."!mark_fail"(0) + lt rx402_pos, -1, rx402_done + eq rx402_pos, -1, rx402_fail jump $I10 - rx400_done: - rx400_cur."!cursor_fail"() - rx400_cur."!cursor_debug"("FAIL ", "statement_mod_loop:sym") - .return (rx400_cur) + rx402_done: + rx402_cur."!cursor_fail"() + rx402_cur."!cursor_debug"("FAIL ", "statement_mod_loop:sym") + .return (rx402_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_mod_loop:sym" :subid("94_1275511697.61926") :method +.sub "!PREFIX__statement_mod_loop:sym" :subid("94_1275600007.84296") :method .annotate 'line', 4 - new $P402, "ResizablePMCArray" - push $P402, "while" - .return ($P402) + new $P404, "ResizablePMCArray" + push $P404, "while" + .return ($P404) .end .namespace ["NQP";"Grammar"] -.sub "statement_mod_loop:sym" :subid("95_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "statement_mod_loop:sym" :subid("95_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx408_tgt - .local int rx408_pos - .local int rx408_off - .local int rx408_eos - .local int rx408_rep - .local pmc rx408_cur - (rx408_cur, rx408_pos, rx408_tgt) = self."!cursor_start"() - rx408_cur."!cursor_debug"("START ", "statement_mod_loop:sym") - .lex unicode:"$\x{a2}", rx408_cur + .local string rx410_tgt + .local int rx410_pos + .local int rx410_off + .local int rx410_eos + .local int rx410_rep + .local pmc rx410_cur + (rx410_cur, rx410_pos, rx410_tgt) = self."!cursor_start"() + rx410_cur."!cursor_debug"("START ", "statement_mod_loop:sym") + .lex unicode:"$\x{a2}", rx410_cur .local pmc match .lex "$/", match - length rx408_eos, rx408_tgt - gt rx408_pos, rx408_eos, rx408_done - set rx408_off, 0 - lt rx408_pos, 2, rx408_start - sub rx408_off, rx408_pos, 1 - substr rx408_tgt, rx408_tgt, rx408_off - rx408_start: + length rx410_eos, rx410_tgt + gt rx410_pos, rx410_eos, rx410_done + set rx410_off, 0 + lt rx410_pos, 2, rx410_start + sub rx410_off, rx410_pos, 1 + substr rx410_tgt, rx410_tgt, rx410_off + rx410_start: $I10 = self.'from'() - ne $I10, -1, rxscan411_done - goto rxscan411_scan - rxscan411_loop: - ($P10) = rx408_cur."from"() + ne $I10, -1, rxscan413_done + goto rxscan413_scan + rxscan413_loop: + ($P10) = rx410_cur."from"() inc $P10 - set rx408_pos, $P10 - ge rx408_pos, rx408_eos, rxscan411_done - rxscan411_scan: - set_addr $I10, rxscan411_loop - rx408_cur."!mark_push"(0, rx408_pos, $I10) - rxscan411_done: -.annotate 'line', 219 + set rx410_pos, $P10 + ge rx410_pos, rx410_eos, rxscan413_done + rxscan413_scan: + set_addr $I10, rxscan413_loop + rx410_cur."!mark_push"(0, rx410_pos, $I10) + rxscan413_done: +.annotate 'line', 220 # rx subcapture "sym" - set_addr $I10, rxcap_412_fail - rx408_cur."!mark_push"(0, rx408_pos, $I10) + set_addr $I10, rxcap_414_fail + rx410_cur."!mark_push"(0, rx410_pos, $I10) # rx literal "until" - add $I11, rx408_pos, 5 - gt $I11, rx408_eos, rx408_fail - sub $I11, rx408_pos, rx408_off - substr $S10, rx408_tgt, $I11, 5 - ne $S10, "until", rx408_fail - add rx408_pos, 5 - set_addr $I10, rxcap_412_fail - ($I12, $I11) = rx408_cur."!mark_peek"($I10) - rx408_cur."!cursor_pos"($I11) - ($P10) = rx408_cur."!cursor_start"() - $P10."!cursor_pass"(rx408_pos, "") - rx408_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx410_pos, 5 + gt $I11, rx410_eos, rx410_fail + sub $I11, rx410_pos, rx410_off + substr $S10, rx410_tgt, $I11, 5 + ne $S10, "until", rx410_fail + add rx410_pos, 5 + set_addr $I10, rxcap_414_fail + ($I12, $I11) = rx410_cur."!mark_peek"($I10) + rx410_cur."!cursor_pos"($I11) + ($P10) = rx410_cur."!cursor_start"() + $P10."!cursor_pass"(rx410_pos, "") + rx410_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_412_done - rxcap_412_fail: - goto rx408_fail - rxcap_412_done: + goto rxcap_414_done + rxcap_414_fail: + goto rx410_fail + rxcap_414_done: # rx subrule "ws" subtype=method negate= - rx408_cur."!cursor_pos"(rx408_pos) - $P10 = rx408_cur."ws"() - unless $P10, rx408_fail - rx408_pos = $P10."pos"() + rx410_cur."!cursor_pos"(rx410_pos) + $P10 = rx410_cur."ws"() + unless $P10, rx410_fail + rx410_pos = $P10."pos"() # rx subrule "EXPR" subtype=capture negate= - rx408_cur."!cursor_pos"(rx408_pos) - $P10 = rx408_cur."EXPR"() - unless $P10, rx408_fail - rx408_cur."!mark_push"(0, -1, 0, $P10) + rx410_cur."!cursor_pos"(rx410_pos) + $P10 = rx410_cur."EXPR"() + unless $P10, rx410_fail + rx410_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("cond") - rx408_pos = $P10."pos"() + rx410_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx408_cur."!cursor_pos"(rx408_pos) - $P10 = rx408_cur."ws"() - unless $P10, rx408_fail - rx408_pos = $P10."pos"() + rx410_cur."!cursor_pos"(rx410_pos) + $P10 = rx410_cur."ws"() + unless $P10, rx410_fail + rx410_pos = $P10."pos"() # rx pass - rx408_cur."!cursor_pass"(rx408_pos, "statement_mod_loop:sym") - rx408_cur."!cursor_debug"("PASS ", "statement_mod_loop:sym", " at pos=", rx408_pos) - .return (rx408_cur) - rx408_fail: -.annotate 'line', 4 - (rx408_rep, rx408_pos, $I10, $P10) = rx408_cur."!mark_fail"(0) - lt rx408_pos, -1, rx408_done - eq rx408_pos, -1, rx408_fail + rx410_cur."!cursor_pass"(rx410_pos, "statement_mod_loop:sym") + rx410_cur."!cursor_debug"("PASS ", "statement_mod_loop:sym", " at pos=", rx410_pos) + .return (rx410_cur) + rx410_fail: +.annotate 'line', 4 + (rx410_rep, rx410_pos, $I10, $P10) = rx410_cur."!mark_fail"(0) + lt rx410_pos, -1, rx410_done + eq rx410_pos, -1, rx410_fail jump $I10 - rx408_done: - rx408_cur."!cursor_fail"() - rx408_cur."!cursor_debug"("FAIL ", "statement_mod_loop:sym") - .return (rx408_cur) + rx410_done: + rx410_cur."!cursor_fail"() + rx410_cur."!cursor_debug"("FAIL ", "statement_mod_loop:sym") + .return (rx410_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__statement_mod_loop:sym" :subid("96_1275511697.61926") :method +.sub "!PREFIX__statement_mod_loop:sym" :subid("96_1275600007.84296") :method .annotate 'line', 4 - new $P410, "ResizablePMCArray" - push $P410, "until" - .return ($P410) + new $P412, "ResizablePMCArray" + push $P412, "until" + .return ($P412) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("97_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("97_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx416_tgt - .local int rx416_pos - .local int rx416_off - .local int rx416_eos - .local int rx416_rep - .local pmc rx416_cur - (rx416_cur, rx416_pos, rx416_tgt) = self."!cursor_start"() - rx416_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx416_cur + .local string rx418_tgt + .local int rx418_pos + .local int rx418_off + .local int rx418_eos + .local int rx418_rep + .local pmc rx418_cur + (rx418_cur, rx418_pos, rx418_tgt) = self."!cursor_start"() + rx418_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx418_cur .local pmc match .lex "$/", match - length rx416_eos, rx416_tgt - gt rx416_pos, rx416_eos, rx416_done - set rx416_off, 0 - lt rx416_pos, 2, rx416_start - sub rx416_off, rx416_pos, 1 - substr rx416_tgt, rx416_tgt, rx416_off - rx416_start: + length rx418_eos, rx418_tgt + gt rx418_pos, rx418_eos, rx418_done + set rx418_off, 0 + lt rx418_pos, 2, rx418_start + sub rx418_off, rx418_pos, 1 + substr rx418_tgt, rx418_tgt, rx418_off + rx418_start: $I10 = self.'from'() - ne $I10, -1, rxscan420_done - goto rxscan420_scan - rxscan420_loop: - ($P10) = rx416_cur."from"() + ne $I10, -1, rxscan422_done + goto rxscan422_scan + rxscan422_loop: + ($P10) = rx418_cur."from"() inc $P10 - set rx416_pos, $P10 - ge rx416_pos, rx416_eos, rxscan420_done - rxscan420_scan: - set_addr $I10, rxscan420_loop - rx416_cur."!mark_push"(0, rx416_pos, $I10) - rxscan420_done: -.annotate 'line', 223 + set rx418_pos, $P10 + ge rx418_pos, rx418_eos, rxscan422_done + rxscan422_scan: + set_addr $I10, rxscan422_loop + rx418_cur."!mark_push"(0, rx418_pos, $I10) + rxscan422_done: +.annotate 'line', 224 # rx subrule "fatarrow" subtype=capture negate= - rx416_cur."!cursor_pos"(rx416_pos) - $P10 = rx416_cur."fatarrow"() - unless $P10, rx416_fail - rx416_cur."!mark_push"(0, -1, 0, $P10) + rx418_cur."!cursor_pos"(rx418_pos) + $P10 = rx418_cur."fatarrow"() + unless $P10, rx418_fail + rx418_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("fatarrow") - rx416_pos = $P10."pos"() + rx418_pos = $P10."pos"() # rx pass - rx416_cur."!cursor_pass"(rx416_pos, "term:sym") - rx416_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx416_pos) - .return (rx416_cur) - rx416_fail: -.annotate 'line', 4 - (rx416_rep, rx416_pos, $I10, $P10) = rx416_cur."!mark_fail"(0) - lt rx416_pos, -1, rx416_done - eq rx416_pos, -1, rx416_fail + rx418_cur."!cursor_pass"(rx418_pos, "term:sym") + rx418_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx418_pos) + .return (rx418_cur) + rx418_fail: +.annotate 'line', 4 + (rx418_rep, rx418_pos, $I10, $P10) = rx418_cur."!mark_fail"(0) + lt rx418_pos, -1, rx418_done + eq rx418_pos, -1, rx418_fail jump $I10 - rx416_done: - rx416_cur."!cursor_fail"() - rx416_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx416_cur) + rx418_done: + rx418_cur."!cursor_fail"() + rx418_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx418_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("98_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("98_1275600007.84296") :method .annotate 'line', 4 - $P418 = self."!PREFIX__!subrule"("fatarrow", "") - new $P419, "ResizablePMCArray" - push $P419, $P418 - .return ($P419) + $P420 = self."!PREFIX__!subrule"("fatarrow", "") + new $P421, "ResizablePMCArray" + push $P421, $P420 + .return ($P421) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("99_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("99_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx422_tgt - .local int rx422_pos - .local int rx422_off - .local int rx422_eos - .local int rx422_rep - .local pmc rx422_cur - (rx422_cur, rx422_pos, rx422_tgt) = self."!cursor_start"() - rx422_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx422_cur + .local string rx424_tgt + .local int rx424_pos + .local int rx424_off + .local int rx424_eos + .local int rx424_rep + .local pmc rx424_cur + (rx424_cur, rx424_pos, rx424_tgt) = self."!cursor_start"() + rx424_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx424_cur .local pmc match .lex "$/", match - length rx422_eos, rx422_tgt - gt rx422_pos, rx422_eos, rx422_done - set rx422_off, 0 - lt rx422_pos, 2, rx422_start - sub rx422_off, rx422_pos, 1 - substr rx422_tgt, rx422_tgt, rx422_off - rx422_start: + length rx424_eos, rx424_tgt + gt rx424_pos, rx424_eos, rx424_done + set rx424_off, 0 + lt rx424_pos, 2, rx424_start + sub rx424_off, rx424_pos, 1 + substr rx424_tgt, rx424_tgt, rx424_off + rx424_start: $I10 = self.'from'() - ne $I10, -1, rxscan426_done - goto rxscan426_scan - rxscan426_loop: - ($P10) = rx422_cur."from"() + ne $I10, -1, rxscan428_done + goto rxscan428_scan + rxscan428_loop: + ($P10) = rx424_cur."from"() inc $P10 - set rx422_pos, $P10 - ge rx422_pos, rx422_eos, rxscan426_done - rxscan426_scan: - set_addr $I10, rxscan426_loop - rx422_cur."!mark_push"(0, rx422_pos, $I10) - rxscan426_done: -.annotate 'line', 224 + set rx424_pos, $P10 + ge rx424_pos, rx424_eos, rxscan428_done + rxscan428_scan: + set_addr $I10, rxscan428_loop + rx424_cur."!mark_push"(0, rx424_pos, $I10) + rxscan428_done: +.annotate 'line', 225 # rx subrule "colonpair" subtype=capture negate= - rx422_cur."!cursor_pos"(rx422_pos) - $P10 = rx422_cur."colonpair"() - unless $P10, rx422_fail - rx422_cur."!mark_push"(0, -1, 0, $P10) + rx424_cur."!cursor_pos"(rx424_pos) + $P10 = rx424_cur."colonpair"() + unless $P10, rx424_fail + rx424_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("colonpair") - rx422_pos = $P10."pos"() + rx424_pos = $P10."pos"() # rx pass - rx422_cur."!cursor_pass"(rx422_pos, "term:sym") - rx422_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx422_pos) - .return (rx422_cur) - rx422_fail: -.annotate 'line', 4 - (rx422_rep, rx422_pos, $I10, $P10) = rx422_cur."!mark_fail"(0) - lt rx422_pos, -1, rx422_done - eq rx422_pos, -1, rx422_fail + rx424_cur."!cursor_pass"(rx424_pos, "term:sym") + rx424_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx424_pos) + .return (rx424_cur) + rx424_fail: +.annotate 'line', 4 + (rx424_rep, rx424_pos, $I10, $P10) = rx424_cur."!mark_fail"(0) + lt rx424_pos, -1, rx424_done + eq rx424_pos, -1, rx424_fail jump $I10 - rx422_done: - rx422_cur."!cursor_fail"() - rx422_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx422_cur) + rx424_done: + rx424_cur."!cursor_fail"() + rx424_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx424_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("100_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("100_1275600007.84296") :method .annotate 'line', 4 - $P424 = self."!PREFIX__!subrule"("colonpair", "") - new $P425, "ResizablePMCArray" - push $P425, $P424 - .return ($P425) + $P426 = self."!PREFIX__!subrule"("colonpair", "") + new $P427, "ResizablePMCArray" + push $P427, $P426 + .return ($P427) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("101_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("101_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx428_tgt - .local int rx428_pos - .local int rx428_off - .local int rx428_eos - .local int rx428_rep - .local pmc rx428_cur - (rx428_cur, rx428_pos, rx428_tgt) = self."!cursor_start"() - rx428_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx428_cur + .local string rx430_tgt + .local int rx430_pos + .local int rx430_off + .local int rx430_eos + .local int rx430_rep + .local pmc rx430_cur + (rx430_cur, rx430_pos, rx430_tgt) = self."!cursor_start"() + rx430_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx430_cur .local pmc match .lex "$/", match - length rx428_eos, rx428_tgt - gt rx428_pos, rx428_eos, rx428_done - set rx428_off, 0 - lt rx428_pos, 2, rx428_start - sub rx428_off, rx428_pos, 1 - substr rx428_tgt, rx428_tgt, rx428_off - rx428_start: + length rx430_eos, rx430_tgt + gt rx430_pos, rx430_eos, rx430_done + set rx430_off, 0 + lt rx430_pos, 2, rx430_start + sub rx430_off, rx430_pos, 1 + substr rx430_tgt, rx430_tgt, rx430_off + rx430_start: $I10 = self.'from'() - ne $I10, -1, rxscan432_done - goto rxscan432_scan - rxscan432_loop: - ($P10) = rx428_cur."from"() + ne $I10, -1, rxscan434_done + goto rxscan434_scan + rxscan434_loop: + ($P10) = rx430_cur."from"() inc $P10 - set rx428_pos, $P10 - ge rx428_pos, rx428_eos, rxscan432_done - rxscan432_scan: - set_addr $I10, rxscan432_loop - rx428_cur."!mark_push"(0, rx428_pos, $I10) - rxscan432_done: -.annotate 'line', 225 + set rx430_pos, $P10 + ge rx430_pos, rx430_eos, rxscan434_done + rxscan434_scan: + set_addr $I10, rxscan434_loop + rx430_cur."!mark_push"(0, rx430_pos, $I10) + rxscan434_done: +.annotate 'line', 226 # rx subrule "variable" subtype=capture negate= - rx428_cur."!cursor_pos"(rx428_pos) - $P10 = rx428_cur."variable"() - unless $P10, rx428_fail - rx428_cur."!mark_push"(0, -1, 0, $P10) + rx430_cur."!cursor_pos"(rx430_pos) + $P10 = rx430_cur."variable"() + unless $P10, rx430_fail + rx430_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("variable") - rx428_pos = $P10."pos"() + rx430_pos = $P10."pos"() # rx pass - rx428_cur."!cursor_pass"(rx428_pos, "term:sym") - rx428_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx428_pos) - .return (rx428_cur) - rx428_fail: -.annotate 'line', 4 - (rx428_rep, rx428_pos, $I10, $P10) = rx428_cur."!mark_fail"(0) - lt rx428_pos, -1, rx428_done - eq rx428_pos, -1, rx428_fail + rx430_cur."!cursor_pass"(rx430_pos, "term:sym") + rx430_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx430_pos) + .return (rx430_cur) + rx430_fail: +.annotate 'line', 4 + (rx430_rep, rx430_pos, $I10, $P10) = rx430_cur."!mark_fail"(0) + lt rx430_pos, -1, rx430_done + eq rx430_pos, -1, rx430_fail jump $I10 - rx428_done: - rx428_cur."!cursor_fail"() - rx428_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx428_cur) + rx430_done: + rx430_cur."!cursor_fail"() + rx430_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx430_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("102_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("102_1275600007.84296") :method .annotate 'line', 4 - $P430 = self."!PREFIX__!subrule"("variable", "") - new $P431, "ResizablePMCArray" - push $P431, $P430 - .return ($P431) + $P432 = self."!PREFIX__!subrule"("variable", "") + new $P433, "ResizablePMCArray" + push $P433, $P432 + .return ($P433) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("103_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("103_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx434_tgt - .local int rx434_pos - .local int rx434_off - .local int rx434_eos - .local int rx434_rep - .local pmc rx434_cur - (rx434_cur, rx434_pos, rx434_tgt) = self."!cursor_start"() - rx434_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx434_cur + .local string rx436_tgt + .local int rx436_pos + .local int rx436_off + .local int rx436_eos + .local int rx436_rep + .local pmc rx436_cur + (rx436_cur, rx436_pos, rx436_tgt) = self."!cursor_start"() + rx436_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx436_cur .local pmc match .lex "$/", match - length rx434_eos, rx434_tgt - gt rx434_pos, rx434_eos, rx434_done - set rx434_off, 0 - lt rx434_pos, 2, rx434_start - sub rx434_off, rx434_pos, 1 - substr rx434_tgt, rx434_tgt, rx434_off - rx434_start: + length rx436_eos, rx436_tgt + gt rx436_pos, rx436_eos, rx436_done + set rx436_off, 0 + lt rx436_pos, 2, rx436_start + sub rx436_off, rx436_pos, 1 + substr rx436_tgt, rx436_tgt, rx436_off + rx436_start: $I10 = self.'from'() - ne $I10, -1, rxscan438_done - goto rxscan438_scan - rxscan438_loop: - ($P10) = rx434_cur."from"() + ne $I10, -1, rxscan440_done + goto rxscan440_scan + rxscan440_loop: + ($P10) = rx436_cur."from"() inc $P10 - set rx434_pos, $P10 - ge rx434_pos, rx434_eos, rxscan438_done - rxscan438_scan: - set_addr $I10, rxscan438_loop - rx434_cur."!mark_push"(0, rx434_pos, $I10) - rxscan438_done: -.annotate 'line', 226 + set rx436_pos, $P10 + ge rx436_pos, rx436_eos, rxscan440_done + rxscan440_scan: + set_addr $I10, rxscan440_loop + rx436_cur."!mark_push"(0, rx436_pos, $I10) + rxscan440_done: +.annotate 'line', 227 # rx subrule "package_declarator" subtype=capture negate= - rx434_cur."!cursor_pos"(rx434_pos) - $P10 = rx434_cur."package_declarator"() - unless $P10, rx434_fail - rx434_cur."!mark_push"(0, -1, 0, $P10) + rx436_cur."!cursor_pos"(rx436_pos) + $P10 = rx436_cur."package_declarator"() + unless $P10, rx436_fail + rx436_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("package_declarator") - rx434_pos = $P10."pos"() + rx436_pos = $P10."pos"() # rx pass - rx434_cur."!cursor_pass"(rx434_pos, "term:sym") - rx434_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx434_pos) - .return (rx434_cur) - rx434_fail: -.annotate 'line', 4 - (rx434_rep, rx434_pos, $I10, $P10) = rx434_cur."!mark_fail"(0) - lt rx434_pos, -1, rx434_done - eq rx434_pos, -1, rx434_fail + rx436_cur."!cursor_pass"(rx436_pos, "term:sym") + rx436_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx436_pos) + .return (rx436_cur) + rx436_fail: +.annotate 'line', 4 + (rx436_rep, rx436_pos, $I10, $P10) = rx436_cur."!mark_fail"(0) + lt rx436_pos, -1, rx436_done + eq rx436_pos, -1, rx436_fail jump $I10 - rx434_done: - rx434_cur."!cursor_fail"() - rx434_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx434_cur) + rx436_done: + rx436_cur."!cursor_fail"() + rx436_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx436_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("104_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("104_1275600007.84296") :method .annotate 'line', 4 - $P436 = self."!PREFIX__!subrule"("package_declarator", "") - new $P437, "ResizablePMCArray" - push $P437, $P436 - .return ($P437) + $P438 = self."!PREFIX__!subrule"("package_declarator", "") + new $P439, "ResizablePMCArray" + push $P439, $P438 + .return ($P439) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("105_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("105_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx440_tgt - .local int rx440_pos - .local int rx440_off - .local int rx440_eos - .local int rx440_rep - .local pmc rx440_cur - (rx440_cur, rx440_pos, rx440_tgt) = self."!cursor_start"() - rx440_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx440_cur + .local string rx442_tgt + .local int rx442_pos + .local int rx442_off + .local int rx442_eos + .local int rx442_rep + .local pmc rx442_cur + (rx442_cur, rx442_pos, rx442_tgt) = self."!cursor_start"() + rx442_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx442_cur .local pmc match .lex "$/", match - length rx440_eos, rx440_tgt - gt rx440_pos, rx440_eos, rx440_done - set rx440_off, 0 - lt rx440_pos, 2, rx440_start - sub rx440_off, rx440_pos, 1 - substr rx440_tgt, rx440_tgt, rx440_off - rx440_start: + length rx442_eos, rx442_tgt + gt rx442_pos, rx442_eos, rx442_done + set rx442_off, 0 + lt rx442_pos, 2, rx442_start + sub rx442_off, rx442_pos, 1 + substr rx442_tgt, rx442_tgt, rx442_off + rx442_start: $I10 = self.'from'() - ne $I10, -1, rxscan444_done - goto rxscan444_scan - rxscan444_loop: - ($P10) = rx440_cur."from"() + ne $I10, -1, rxscan446_done + goto rxscan446_scan + rxscan446_loop: + ($P10) = rx442_cur."from"() inc $P10 - set rx440_pos, $P10 - ge rx440_pos, rx440_eos, rxscan444_done - rxscan444_scan: - set_addr $I10, rxscan444_loop - rx440_cur."!mark_push"(0, rx440_pos, $I10) - rxscan444_done: -.annotate 'line', 227 + set rx442_pos, $P10 + ge rx442_pos, rx442_eos, rxscan446_done + rxscan446_scan: + set_addr $I10, rxscan446_loop + rx442_cur."!mark_push"(0, rx442_pos, $I10) + rxscan446_done: +.annotate 'line', 228 # rx subrule "scope_declarator" subtype=capture negate= - rx440_cur."!cursor_pos"(rx440_pos) - $P10 = rx440_cur."scope_declarator"() - unless $P10, rx440_fail - rx440_cur."!mark_push"(0, -1, 0, $P10) + rx442_cur."!cursor_pos"(rx442_pos) + $P10 = rx442_cur."scope_declarator"() + unless $P10, rx442_fail + rx442_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("scope_declarator") - rx440_pos = $P10."pos"() + rx442_pos = $P10."pos"() # rx pass - rx440_cur."!cursor_pass"(rx440_pos, "term:sym") - rx440_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx440_pos) - .return (rx440_cur) - rx440_fail: -.annotate 'line', 4 - (rx440_rep, rx440_pos, $I10, $P10) = rx440_cur."!mark_fail"(0) - lt rx440_pos, -1, rx440_done - eq rx440_pos, -1, rx440_fail + rx442_cur."!cursor_pass"(rx442_pos, "term:sym") + rx442_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx442_pos) + .return (rx442_cur) + rx442_fail: +.annotate 'line', 4 + (rx442_rep, rx442_pos, $I10, $P10) = rx442_cur."!mark_fail"(0) + lt rx442_pos, -1, rx442_done + eq rx442_pos, -1, rx442_fail jump $I10 - rx440_done: - rx440_cur."!cursor_fail"() - rx440_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx440_cur) + rx442_done: + rx442_cur."!cursor_fail"() + rx442_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx442_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("106_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("106_1275600007.84296") :method .annotate 'line', 4 - $P442 = self."!PREFIX__!subrule"("scope_declarator", "") - new $P443, "ResizablePMCArray" - push $P443, $P442 - .return ($P443) + $P444 = self."!PREFIX__!subrule"("scope_declarator", "") + new $P445, "ResizablePMCArray" + push $P445, $P444 + .return ($P445) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("107_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("107_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx446_tgt - .local int rx446_pos - .local int rx446_off - .local int rx446_eos - .local int rx446_rep - .local pmc rx446_cur - (rx446_cur, rx446_pos, rx446_tgt) = self."!cursor_start"() - rx446_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx446_cur + .local string rx448_tgt + .local int rx448_pos + .local int rx448_off + .local int rx448_eos + .local int rx448_rep + .local pmc rx448_cur + (rx448_cur, rx448_pos, rx448_tgt) = self."!cursor_start"() + rx448_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx448_cur .local pmc match .lex "$/", match - length rx446_eos, rx446_tgt - gt rx446_pos, rx446_eos, rx446_done - set rx446_off, 0 - lt rx446_pos, 2, rx446_start - sub rx446_off, rx446_pos, 1 - substr rx446_tgt, rx446_tgt, rx446_off - rx446_start: + length rx448_eos, rx448_tgt + gt rx448_pos, rx448_eos, rx448_done + set rx448_off, 0 + lt rx448_pos, 2, rx448_start + sub rx448_off, rx448_pos, 1 + substr rx448_tgt, rx448_tgt, rx448_off + rx448_start: $I10 = self.'from'() - ne $I10, -1, rxscan450_done - goto rxscan450_scan - rxscan450_loop: - ($P10) = rx446_cur."from"() + ne $I10, -1, rxscan452_done + goto rxscan452_scan + rxscan452_loop: + ($P10) = rx448_cur."from"() inc $P10 - set rx446_pos, $P10 - ge rx446_pos, rx446_eos, rxscan450_done - rxscan450_scan: - set_addr $I10, rxscan450_loop - rx446_cur."!mark_push"(0, rx446_pos, $I10) - rxscan450_done: -.annotate 'line', 228 + set rx448_pos, $P10 + ge rx448_pos, rx448_eos, rxscan452_done + rxscan452_scan: + set_addr $I10, rxscan452_loop + rx448_cur."!mark_push"(0, rx448_pos, $I10) + rxscan452_done: +.annotate 'line', 229 # rx subrule "routine_declarator" subtype=capture negate= - rx446_cur."!cursor_pos"(rx446_pos) - $P10 = rx446_cur."routine_declarator"() - unless $P10, rx446_fail - rx446_cur."!mark_push"(0, -1, 0, $P10) + rx448_cur."!cursor_pos"(rx448_pos) + $P10 = rx448_cur."routine_declarator"() + unless $P10, rx448_fail + rx448_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("routine_declarator") - rx446_pos = $P10."pos"() + rx448_pos = $P10."pos"() # rx pass - rx446_cur."!cursor_pass"(rx446_pos, "term:sym") - rx446_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx446_pos) - .return (rx446_cur) - rx446_fail: -.annotate 'line', 4 - (rx446_rep, rx446_pos, $I10, $P10) = rx446_cur."!mark_fail"(0) - lt rx446_pos, -1, rx446_done - eq rx446_pos, -1, rx446_fail + rx448_cur."!cursor_pass"(rx448_pos, "term:sym") + rx448_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx448_pos) + .return (rx448_cur) + rx448_fail: +.annotate 'line', 4 + (rx448_rep, rx448_pos, $I10, $P10) = rx448_cur."!mark_fail"(0) + lt rx448_pos, -1, rx448_done + eq rx448_pos, -1, rx448_fail jump $I10 - rx446_done: - rx446_cur."!cursor_fail"() - rx446_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx446_cur) + rx448_done: + rx448_cur."!cursor_fail"() + rx448_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx448_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("108_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("108_1275600007.84296") :method .annotate 'line', 4 - $P448 = self."!PREFIX__!subrule"("routine_declarator", "") - new $P449, "ResizablePMCArray" - push $P449, $P448 - .return ($P449) + $P450 = self."!PREFIX__!subrule"("routine_declarator", "") + new $P451, "ResizablePMCArray" + push $P451, $P450 + .return ($P451) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("109_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("109_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx452_tgt - .local int rx452_pos - .local int rx452_off - .local int rx452_eos - .local int rx452_rep - .local pmc rx452_cur - (rx452_cur, rx452_pos, rx452_tgt) = self."!cursor_start"() - rx452_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx452_cur + .const 'Sub' $P459 = "111_1275600007.84296" + capture_lex $P459 + .local string rx454_tgt + .local int rx454_pos + .local int rx454_off + .local int rx454_eos + .local int rx454_rep + .local pmc rx454_cur + (rx454_cur, rx454_pos, rx454_tgt) = self."!cursor_start"() + rx454_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx454_cur .local pmc match .lex "$/", match - length rx452_eos, rx452_tgt - gt rx452_pos, rx452_eos, rx452_done - set rx452_off, 0 - lt rx452_pos, 2, rx452_start - sub rx452_off, rx452_pos, 1 - substr rx452_tgt, rx452_tgt, rx452_off - rx452_start: + length rx454_eos, rx454_tgt + gt rx454_pos, rx454_eos, rx454_done + set rx454_off, 0 + lt rx454_pos, 2, rx454_start + sub rx454_off, rx454_pos, 1 + substr rx454_tgt, rx454_tgt, rx454_off + rx454_start: $I10 = self.'from'() - ne $I10, -1, rxscan456_done - goto rxscan456_scan - rxscan456_loop: - ($P10) = rx452_cur."from"() + ne $I10, -1, rxscan457_done + goto rxscan457_scan + rxscan457_loop: + ($P10) = rx454_cur."from"() inc $P10 - set rx452_pos, $P10 - ge rx452_pos, rx452_eos, rxscan456_done - rxscan456_scan: - set_addr $I10, rxscan456_loop - rx452_cur."!mark_push"(0, rx452_pos, $I10) - rxscan456_done: -.annotate 'line', 229 - # rx subrule "regex_declarator" subtype=capture negate= - rx452_cur."!cursor_pos"(rx452_pos) - $P10 = rx452_cur."regex_declarator"() - unless $P10, rx452_fail - rx452_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("regex_declarator") - rx452_pos = $P10."pos"() + set rx454_pos, $P10 + ge rx454_pos, rx454_eos, rxscan457_done + rxscan457_scan: + set_addr $I10, rxscan457_loop + rx454_cur."!mark_push"(0, rx454_pos, $I10) + rxscan457_done: +.annotate 'line', 230 + # rx subrule "before" subtype=zerowidth negate= + rx454_cur."!cursor_pos"(rx454_pos) + .const 'Sub' $P459 = "111_1275600007.84296" + capture_lex $P459 + $P10 = rx454_cur."before"($P459) + unless $P10, rx454_fail + # rx subrule "multi_declarator" subtype=capture negate= + rx454_cur."!cursor_pos"(rx454_pos) + $P10 = rx454_cur."multi_declarator"() + unless $P10, rx454_fail + rx454_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("multi_declarator") + rx454_pos = $P10."pos"() # rx pass - rx452_cur."!cursor_pass"(rx452_pos, "term:sym") - rx452_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx452_pos) - .return (rx452_cur) - rx452_fail: -.annotate 'line', 4 - (rx452_rep, rx452_pos, $I10, $P10) = rx452_cur."!mark_fail"(0) - lt rx452_pos, -1, rx452_done - eq rx452_pos, -1, rx452_fail + rx454_cur."!cursor_pass"(rx454_pos, "term:sym") + rx454_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx454_pos) + .return (rx454_cur) + rx454_fail: +.annotate 'line', 4 + (rx454_rep, rx454_pos, $I10, $P10) = rx454_cur."!mark_fail"(0) + lt rx454_pos, -1, rx454_done + eq rx454_pos, -1, rx454_fail jump $I10 - rx452_done: - rx452_cur."!cursor_fail"() - rx452_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx452_cur) + rx454_done: + rx454_cur."!cursor_fail"() + rx454_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx454_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("110_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("110_1275600007.84296") :method .annotate 'line', 4 - $P454 = self."!PREFIX__!subrule"("regex_declarator", "") - new $P455, "ResizablePMCArray" - push $P455, $P454 - .return ($P455) + new $P456, "ResizablePMCArray" + push $P456, "" + .return ($P456) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("111_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 4 - .local string rx458_tgt - .local int rx458_pos - .local int rx458_off - .local int rx458_eos - .local int rx458_rep - .local pmc rx458_cur - (rx458_cur, rx458_pos, rx458_tgt) = self."!cursor_start"() - rx458_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx458_cur +.sub "_block458" :anon :subid("111_1275600007.84296") :method :outer("109_1275600007.84296") +.annotate 'line', 230 + .local string rx460_tgt + .local int rx460_pos + .local int rx460_off + .local int rx460_eos + .local int rx460_rep + .local pmc rx460_cur + (rx460_cur, rx460_pos, rx460_tgt) = self."!cursor_start"() + rx460_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx460_cur .local pmc match .lex "$/", match - length rx458_eos, rx458_tgt - gt rx458_pos, rx458_eos, rx458_done - set rx458_off, 0 - lt rx458_pos, 2, rx458_start - sub rx458_off, rx458_pos, 1 - substr rx458_tgt, rx458_tgt, rx458_off - rx458_start: + length rx460_eos, rx460_tgt + gt rx460_pos, rx460_eos, rx460_done + set rx460_off, 0 + lt rx460_pos, 2, rx460_start + sub rx460_off, rx460_pos, 1 + substr rx460_tgt, rx460_tgt, rx460_off + rx460_start: $I10 = self.'from'() - ne $I10, -1, rxscan462_done - goto rxscan462_scan - rxscan462_loop: - ($P10) = rx458_cur."from"() + ne $I10, -1, rxscan461_done + goto rxscan461_scan + rxscan461_loop: + ($P10) = rx460_cur."from"() inc $P10 - set rx458_pos, $P10 - ge rx458_pos, rx458_eos, rxscan462_done - rxscan462_scan: - set_addr $I10, rxscan462_loop - rx458_cur."!mark_push"(0, rx458_pos, $I10) - rxscan462_done: -.annotate 'line', 230 - # rx subrule "statement_prefix" subtype=capture negate= - rx458_cur."!cursor_pos"(rx458_pos) - $P10 = rx458_cur."statement_prefix"() - unless $P10, rx458_fail - rx458_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("statement_prefix") - rx458_pos = $P10."pos"() + set rx460_pos, $P10 + ge rx460_pos, rx460_eos, rxscan461_done + rxscan461_scan: + set_addr $I10, rxscan461_loop + rx460_cur."!mark_push"(0, rx460_pos, $I10) + rxscan461_done: + alt462_0: + set_addr $I10, alt462_1 + rx460_cur."!mark_push"(0, rx460_pos, $I10) + # rx literal "multi" + add $I11, rx460_pos, 5 + gt $I11, rx460_eos, rx460_fail + sub $I11, rx460_pos, rx460_off + substr $S10, rx460_tgt, $I11, 5 + ne $S10, "multi", rx460_fail + add rx460_pos, 5 + goto alt462_end + alt462_1: + set_addr $I10, alt462_2 + rx460_cur."!mark_push"(0, rx460_pos, $I10) + # rx literal "proto" + add $I11, rx460_pos, 5 + gt $I11, rx460_eos, rx460_fail + sub $I11, rx460_pos, rx460_off + substr $S10, rx460_tgt, $I11, 5 + ne $S10, "proto", rx460_fail + add rx460_pos, 5 + goto alt462_end + alt462_2: + # rx literal "only" + add $I11, rx460_pos, 4 + gt $I11, rx460_eos, rx460_fail + sub $I11, rx460_pos, rx460_off + substr $S10, rx460_tgt, $I11, 4 + ne $S10, "only", rx460_fail + add rx460_pos, 4 + alt462_end: # rx pass - rx458_cur."!cursor_pass"(rx458_pos, "term:sym") - rx458_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx458_pos) - .return (rx458_cur) - rx458_fail: -.annotate 'line', 4 - (rx458_rep, rx458_pos, $I10, $P10) = rx458_cur."!mark_fail"(0) - lt rx458_pos, -1, rx458_done - eq rx458_pos, -1, rx458_fail + rx460_cur."!cursor_pass"(rx460_pos, "") + rx460_cur."!cursor_debug"("PASS ", "", " at pos=", rx460_pos) + .return (rx460_cur) + rx460_fail: + (rx460_rep, rx460_pos, $I10, $P10) = rx460_cur."!mark_fail"(0) + lt rx460_pos, -1, rx460_done + eq rx460_pos, -1, rx460_fail jump $I10 - rx458_done: - rx458_cur."!cursor_fail"() - rx458_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx458_cur) + rx460_done: + rx460_cur."!cursor_fail"() + rx460_cur."!cursor_debug"("FAIL ", "") + .return (rx460_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("112_1275511697.61926") :method -.annotate 'line', 4 - $P460 = self."!PREFIX__!subrule"("statement_prefix", "") - new $P461, "ResizablePMCArray" - push $P461, $P460 - .return ($P461) -.end - - -.namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("113_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("112_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 .local string rx464_tgt .local int rx464_pos @@ -5718,7 +5750,7 @@ NQP::Compiler - NQP compiler .local int rx464_rep .local pmc rx464_cur (rx464_cur, rx464_pos, rx464_tgt) = self."!cursor_start"() - rx464_cur."!cursor_debug"("START ", "term:sym") + rx464_cur."!cursor_debug"("START ", "term:sym") .lex unicode:"$\x{a2}", rx464_cur .local pmc match .lex "$/", match @@ -5730,32 +5762,28 @@ NQP::Compiler - NQP compiler substr rx464_tgt, rx464_tgt, rx464_off rx464_start: $I10 = self.'from'() - ne $I10, -1, rxscan467_done - goto rxscan467_scan - rxscan467_loop: + ne $I10, -1, rxscan468_done + goto rxscan468_scan + rxscan468_loop: ($P10) = rx464_cur."from"() inc $P10 set rx464_pos, $P10 - ge rx464_pos, rx464_eos, rxscan467_done - rxscan467_scan: - set_addr $I10, rxscan467_loop + ge rx464_pos, rx464_eos, rxscan468_done + rxscan468_scan: + set_addr $I10, rxscan468_loop rx464_cur."!mark_push"(0, rx464_pos, $I10) - rxscan467_done: + rxscan468_done: .annotate 'line', 231 - # rx subrule "lambda" subtype=zerowidth negate= - rx464_cur."!cursor_pos"(rx464_pos) - $P10 = rx464_cur."lambda"() - unless $P10, rx464_fail - # rx subrule "pblock" subtype=capture negate= + # rx subrule "regex_declarator" subtype=capture negate= rx464_cur."!cursor_pos"(rx464_pos) - $P10 = rx464_cur."pblock"() + $P10 = rx464_cur."regex_declarator"() unless $P10, rx464_fail rx464_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("pblock") + $P10."!cursor_names"("regex_declarator") rx464_pos = $P10."pos"() # rx pass - rx464_cur."!cursor_pass"(rx464_pos, "term:sym") - rx464_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx464_pos) + rx464_cur."!cursor_pass"(rx464_pos, "term:sym") + rx464_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx464_pos) .return (rx464_cur) rx464_fail: .annotate 'line', 4 @@ -5765,271 +5793,269 @@ NQP::Compiler - NQP compiler jump $I10 rx464_done: rx464_cur."!cursor_fail"() - rx464_cur."!cursor_debug"("FAIL ", "term:sym") + rx464_cur."!cursor_debug"("FAIL ", "term:sym") .return (rx464_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("114_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("113_1275600007.84296") :method .annotate 'line', 4 - new $P466, "ResizablePMCArray" - push $P466, "" - .return ($P466) + $P466 = self."!PREFIX__!subrule"("regex_declarator", "") + new $P467, "ResizablePMCArray" + push $P467, $P466 + .return ($P467) .end .namespace ["NQP";"Grammar"] -.sub "fatarrow" :subid("115_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("114_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx469_tgt - .local int rx469_pos - .local int rx469_off - .local int rx469_eos - .local int rx469_rep - .local pmc rx469_cur - (rx469_cur, rx469_pos, rx469_tgt) = self."!cursor_start"() - rx469_cur."!cursor_debug"("START ", "fatarrow") - .lex unicode:"$\x{a2}", rx469_cur + .local string rx470_tgt + .local int rx470_pos + .local int rx470_off + .local int rx470_eos + .local int rx470_rep + .local pmc rx470_cur + (rx470_cur, rx470_pos, rx470_tgt) = self."!cursor_start"() + rx470_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx470_cur .local pmc match .lex "$/", match - length rx469_eos, rx469_tgt - gt rx469_pos, rx469_eos, rx469_done - set rx469_off, 0 - lt rx469_pos, 2, rx469_start - sub rx469_off, rx469_pos, 1 - substr rx469_tgt, rx469_tgt, rx469_off - rx469_start: + length rx470_eos, rx470_tgt + gt rx470_pos, rx470_eos, rx470_done + set rx470_off, 0 + lt rx470_pos, 2, rx470_start + sub rx470_off, rx470_pos, 1 + substr rx470_tgt, rx470_tgt, rx470_off + rx470_start: $I10 = self.'from'() - ne $I10, -1, rxscan473_done - goto rxscan473_scan - rxscan473_loop: - ($P10) = rx469_cur."from"() + ne $I10, -1, rxscan474_done + goto rxscan474_scan + rxscan474_loop: + ($P10) = rx470_cur."from"() inc $P10 - set rx469_pos, $P10 - ge rx469_pos, rx469_eos, rxscan473_done - rxscan473_scan: - set_addr $I10, rxscan473_loop - rx469_cur."!mark_push"(0, rx469_pos, $I10) - rxscan473_done: -.annotate 'line', 234 - # rx subrule "identifier" subtype=capture negate= - rx469_cur."!cursor_pos"(rx469_pos) - $P10 = rx469_cur."identifier"() - unless $P10, rx469_fail - rx469_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("key") - rx469_pos = $P10."pos"() - # rx rxquantr474 ** 0..* - set_addr $I475, rxquantr474_done - rx469_cur."!mark_push"(0, rx469_pos, $I475) - rxquantr474_loop: - # rx enumcharlist negate=0 - ge rx469_pos, rx469_eos, rx469_fail - sub $I10, rx469_pos, rx469_off - substr $S10, rx469_tgt, $I10, 1 - index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx469_fail - inc rx469_pos - (rx469_rep) = rx469_cur."!mark_commit"($I475) - rx469_cur."!mark_push"(rx469_rep, rx469_pos, $I475) - goto rxquantr474_loop - rxquantr474_done: - # rx literal "=>" - add $I11, rx469_pos, 2 - gt $I11, rx469_eos, rx469_fail - sub $I11, rx469_pos, rx469_off - substr $S10, rx469_tgt, $I11, 2 - ne $S10, "=>", rx469_fail - add rx469_pos, 2 - # rx subrule "ws" subtype=method negate= - rx469_cur."!cursor_pos"(rx469_pos) - $P10 = rx469_cur."ws"() - unless $P10, rx469_fail - rx469_pos = $P10."pos"() - # rx subrule "EXPR" subtype=capture negate= - rx469_cur."!cursor_pos"(rx469_pos) - $P10 = rx469_cur."EXPR"("i=") - unless $P10, rx469_fail - rx469_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("val") - rx469_pos = $P10."pos"() + set rx470_pos, $P10 + ge rx470_pos, rx470_eos, rxscan474_done + rxscan474_scan: + set_addr $I10, rxscan474_loop + rx470_cur."!mark_push"(0, rx470_pos, $I10) + rxscan474_done: +.annotate 'line', 232 + # rx subrule "statement_prefix" subtype=capture negate= + rx470_cur."!cursor_pos"(rx470_pos) + $P10 = rx470_cur."statement_prefix"() + unless $P10, rx470_fail + rx470_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("statement_prefix") + rx470_pos = $P10."pos"() + # rx pass + rx470_cur."!cursor_pass"(rx470_pos, "term:sym") + rx470_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx470_pos) + .return (rx470_cur) + rx470_fail: +.annotate 'line', 4 + (rx470_rep, rx470_pos, $I10, $P10) = rx470_cur."!mark_fail"(0) + lt rx470_pos, -1, rx470_done + eq rx470_pos, -1, rx470_fail + jump $I10 + rx470_done: + rx470_cur."!cursor_fail"() + rx470_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx470_cur) + .return () +.end + + +.namespace ["NQP";"Grammar"] +.sub "!PREFIX__term:sym" :subid("115_1275600007.84296") :method +.annotate 'line', 4 + $P472 = self."!PREFIX__!subrule"("statement_prefix", "") + new $P473, "ResizablePMCArray" + push $P473, $P472 + .return ($P473) +.end + + +.namespace ["NQP";"Grammar"] +.sub "term:sym" :subid("116_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 4 + .local string rx476_tgt + .local int rx476_pos + .local int rx476_off + .local int rx476_eos + .local int rx476_rep + .local pmc rx476_cur + (rx476_cur, rx476_pos, rx476_tgt) = self."!cursor_start"() + rx476_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx476_cur + .local pmc match + .lex "$/", match + length rx476_eos, rx476_tgt + gt rx476_pos, rx476_eos, rx476_done + set rx476_off, 0 + lt rx476_pos, 2, rx476_start + sub rx476_off, rx476_pos, 1 + substr rx476_tgt, rx476_tgt, rx476_off + rx476_start: + $I10 = self.'from'() + ne $I10, -1, rxscan479_done + goto rxscan479_scan + rxscan479_loop: + ($P10) = rx476_cur."from"() + inc $P10 + set rx476_pos, $P10 + ge rx476_pos, rx476_eos, rxscan479_done + rxscan479_scan: + set_addr $I10, rxscan479_loop + rx476_cur."!mark_push"(0, rx476_pos, $I10) + rxscan479_done: .annotate 'line', 233 + # rx subrule "lambda" subtype=zerowidth negate= + rx476_cur."!cursor_pos"(rx476_pos) + $P10 = rx476_cur."lambda"() + unless $P10, rx476_fail + # rx subrule "pblock" subtype=capture negate= + rx476_cur."!cursor_pos"(rx476_pos) + $P10 = rx476_cur."pblock"() + unless $P10, rx476_fail + rx476_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("pblock") + rx476_pos = $P10."pos"() # rx pass - rx469_cur."!cursor_pass"(rx469_pos, "fatarrow") - rx469_cur."!cursor_debug"("PASS ", "fatarrow", " at pos=", rx469_pos) - .return (rx469_cur) - rx469_fail: -.annotate 'line', 4 - (rx469_rep, rx469_pos, $I10, $P10) = rx469_cur."!mark_fail"(0) - lt rx469_pos, -1, rx469_done - eq rx469_pos, -1, rx469_fail + rx476_cur."!cursor_pass"(rx476_pos, "term:sym") + rx476_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx476_pos) + .return (rx476_cur) + rx476_fail: +.annotate 'line', 4 + (rx476_rep, rx476_pos, $I10, $P10) = rx476_cur."!mark_fail"(0) + lt rx476_pos, -1, rx476_done + eq rx476_pos, -1, rx476_fail jump $I10 - rx469_done: - rx469_cur."!cursor_fail"() - rx469_cur."!cursor_debug"("FAIL ", "fatarrow") - .return (rx469_cur) + rx476_done: + rx476_cur."!cursor_fail"() + rx476_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx476_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__fatarrow" :subid("116_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("117_1275600007.84296") :method .annotate 'line', 4 - $P471 = self."!PREFIX__!subrule"("key", "") - new $P472, "ResizablePMCArray" - push $P472, $P471 - .return ($P472) + new $P478, "ResizablePMCArray" + push $P478, "" + .return ($P478) .end .namespace ["NQP";"Grammar"] -.sub "colonpair" :subid("117_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "fatarrow" :subid("118_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx477_tgt - .local int rx477_pos - .local int rx477_off - .local int rx477_eos - .local int rx477_rep - .local pmc rx477_cur - (rx477_cur, rx477_pos, rx477_tgt) = self."!cursor_start"() - rx477_cur."!cursor_debug"("START ", "colonpair") - rx477_cur."!cursor_caparray"("circumfix") - .lex unicode:"$\x{a2}", rx477_cur + .local string rx481_tgt + .local int rx481_pos + .local int rx481_off + .local int rx481_eos + .local int rx481_rep + .local pmc rx481_cur + (rx481_cur, rx481_pos, rx481_tgt) = self."!cursor_start"() + rx481_cur."!cursor_debug"("START ", "fatarrow") + .lex unicode:"$\x{a2}", rx481_cur .local pmc match .lex "$/", match - length rx477_eos, rx477_tgt - gt rx477_pos, rx477_eos, rx477_done - set rx477_off, 0 - lt rx477_pos, 2, rx477_start - sub rx477_off, rx477_pos, 1 - substr rx477_tgt, rx477_tgt, rx477_off - rx477_start: + length rx481_eos, rx481_tgt + gt rx481_pos, rx481_eos, rx481_done + set rx481_off, 0 + lt rx481_pos, 2, rx481_start + sub rx481_off, rx481_pos, 1 + substr rx481_tgt, rx481_tgt, rx481_off + rx481_start: $I10 = self.'from'() - ne $I10, -1, rxscan483_done - goto rxscan483_scan - rxscan483_loop: - ($P10) = rx477_cur."from"() + ne $I10, -1, rxscan485_done + goto rxscan485_scan + rxscan485_loop: + ($P10) = rx481_cur."from"() inc $P10 - set rx477_pos, $P10 - ge rx477_pos, rx477_eos, rxscan483_done - rxscan483_scan: - set_addr $I10, rxscan483_loop - rx477_cur."!mark_push"(0, rx477_pos, $I10) - rxscan483_done: -.annotate 'line', 238 - # rx literal ":" - add $I11, rx477_pos, 1 - gt $I11, rx477_eos, rx477_fail - sub $I11, rx477_pos, rx477_off - substr $S10, rx477_tgt, $I11, 1 - ne $S10, ":", rx477_fail - add rx477_pos, 1 - alt484_0: -.annotate 'line', 239 - set_addr $I10, alt484_1 - rx477_cur."!mark_push"(0, rx477_pos, $I10) -.annotate 'line', 240 - # rx subcapture "not" - set_addr $I10, rxcap_485_fail - rx477_cur."!mark_push"(0, rx477_pos, $I10) - # rx literal "!" - add $I11, rx477_pos, 1 - gt $I11, rx477_eos, rx477_fail - sub $I11, rx477_pos, rx477_off - substr $S10, rx477_tgt, $I11, 1 - ne $S10, "!", rx477_fail - add rx477_pos, 1 - set_addr $I10, rxcap_485_fail - ($I12, $I11) = rx477_cur."!mark_peek"($I10) - rx477_cur."!cursor_pos"($I11) - ($P10) = rx477_cur."!cursor_start"() - $P10."!cursor_pass"(rx477_pos, "") - rx477_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("not") - goto rxcap_485_done - rxcap_485_fail: - goto rx477_fail - rxcap_485_done: - # rx subrule "identifier" subtype=capture negate= - rx477_cur."!cursor_pos"(rx477_pos) - $P10 = rx477_cur."identifier"() - unless $P10, rx477_fail - rx477_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("identifier") - rx477_pos = $P10."pos"() - goto alt484_end - alt484_1: - set_addr $I10, alt484_2 - rx477_cur."!mark_push"(0, rx477_pos, $I10) -.annotate 'line', 241 + set rx481_pos, $P10 + ge rx481_pos, rx481_eos, rxscan485_done + rxscan485_scan: + set_addr $I10, rxscan485_loop + rx481_cur."!mark_push"(0, rx481_pos, $I10) + rxscan485_done: +.annotate 'line', 236 # rx subrule "identifier" subtype=capture negate= - rx477_cur."!cursor_pos"(rx477_pos) - $P10 = rx477_cur."identifier"() - unless $P10, rx477_fail - rx477_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("identifier") - rx477_pos = $P10."pos"() - # rx rxquantr486 ** 0..1 + rx481_cur."!cursor_pos"(rx481_pos) + $P10 = rx481_cur."identifier"() + unless $P10, rx481_fail + rx481_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("key") + rx481_pos = $P10."pos"() + # rx rxquantr486 ** 0..* set_addr $I487, rxquantr486_done - rx477_cur."!mark_push"(0, rx477_pos, $I487) + rx481_cur."!mark_push"(0, rx481_pos, $I487) rxquantr486_loop: - # rx subrule "circumfix" subtype=capture negate= - rx477_cur."!cursor_pos"(rx477_pos) - $P10 = rx477_cur."circumfix"() - unless $P10, rx477_fail - rx477_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("circumfix") - rx477_pos = $P10."pos"() - (rx477_rep) = rx477_cur."!mark_commit"($I487) + # rx enumcharlist negate=0 + ge rx481_pos, rx481_eos, rx481_fail + sub $I10, rx481_pos, rx481_off + substr $S10, rx481_tgt, $I10, 1 + index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 + lt $I11, 0, rx481_fail + inc rx481_pos + (rx481_rep) = rx481_cur."!mark_commit"($I487) + rx481_cur."!mark_push"(rx481_rep, rx481_pos, $I487) + goto rxquantr486_loop rxquantr486_done: - goto alt484_end - alt484_2: -.annotate 'line', 242 - # rx subrule "circumfix" subtype=capture negate= - rx477_cur."!cursor_pos"(rx477_pos) - $P10 = rx477_cur."circumfix"() - unless $P10, rx477_fail - rx477_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("circumfix") - rx477_pos = $P10."pos"() - alt484_end: -.annotate 'line', 237 + # rx literal "=>" + add $I11, rx481_pos, 2 + gt $I11, rx481_eos, rx481_fail + sub $I11, rx481_pos, rx481_off + substr $S10, rx481_tgt, $I11, 2 + ne $S10, "=>", rx481_fail + add rx481_pos, 2 + # rx subrule "ws" subtype=method negate= + rx481_cur."!cursor_pos"(rx481_pos) + $P10 = rx481_cur."ws"() + unless $P10, rx481_fail + rx481_pos = $P10."pos"() + # rx subrule "EXPR" subtype=capture negate= + rx481_cur."!cursor_pos"(rx481_pos) + $P10 = rx481_cur."EXPR"("i=") + unless $P10, rx481_fail + rx481_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("val") + rx481_pos = $P10."pos"() +.annotate 'line', 235 # rx pass - rx477_cur."!cursor_pass"(rx477_pos, "colonpair") - rx477_cur."!cursor_debug"("PASS ", "colonpair", " at pos=", rx477_pos) - .return (rx477_cur) - rx477_fail: -.annotate 'line', 4 - (rx477_rep, rx477_pos, $I10, $P10) = rx477_cur."!mark_fail"(0) - lt rx477_pos, -1, rx477_done - eq rx477_pos, -1, rx477_fail + rx481_cur."!cursor_pass"(rx481_pos, "fatarrow") + rx481_cur."!cursor_debug"("PASS ", "fatarrow", " at pos=", rx481_pos) + .return (rx481_cur) + rx481_fail: +.annotate 'line', 4 + (rx481_rep, rx481_pos, $I10, $P10) = rx481_cur."!mark_fail"(0) + lt rx481_pos, -1, rx481_done + eq rx481_pos, -1, rx481_fail jump $I10 - rx477_done: - rx477_cur."!cursor_fail"() - rx477_cur."!cursor_debug"("FAIL ", "colonpair") - .return (rx477_cur) + rx481_done: + rx481_cur."!cursor_fail"() + rx481_cur."!cursor_debug"("FAIL ", "fatarrow") + .return (rx481_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__colonpair" :subid("118_1275511697.61926") :method +.sub "!PREFIX__fatarrow" :subid("119_1275600007.84296") :method .annotate 'line', 4 - $P479 = self."!PREFIX__!subrule"("circumfix", ":") - $P480 = self."!PREFIX__!subrule"("identifier", ":") - $P481 = self."!PREFIX__!subrule"("identifier", ":!") - new $P482, "ResizablePMCArray" - push $P482, $P479 - push $P482, $P480 - push $P482, $P481 - .return ($P482) + $P483 = self."!PREFIX__!subrule"("key", "") + new $P484, "ResizablePMCArray" + push $P484, $P483 + .return ($P484) .end .namespace ["NQP";"Grammar"] -.sub "variable" :subid("119_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "colonpair" :subid("120_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 .local string rx489_tgt .local int rx489_pos @@ -6038,8 +6064,8 @@ NQP::Compiler - NQP compiler .local int rx489_rep .local pmc rx489_cur (rx489_cur, rx489_pos, rx489_tgt) = self."!cursor_start"() - rx489_cur."!cursor_debug"("START ", "variable") - rx489_cur."!cursor_caparray"("twigil") + rx489_cur."!cursor_debug"("START ", "colonpair") + rx489_cur."!cursor_caparray"("circumfix") .lex unicode:"$\x{a2}", rx489_cur .local pmc match .lex "$/", match @@ -6051,124 +6077,98 @@ NQP::Compiler - NQP compiler substr rx489_tgt, rx489_tgt, rx489_off rx489_start: $I10 = self.'from'() - ne $I10, -1, rxscan494_done - goto rxscan494_scan - rxscan494_loop: + ne $I10, -1, rxscan495_done + goto rxscan495_scan + rxscan495_loop: ($P10) = rx489_cur."from"() inc $P10 set rx489_pos, $P10 - ge rx489_pos, rx489_eos, rxscan494_done - rxscan494_scan: - set_addr $I10, rxscan494_loop + ge rx489_pos, rx489_eos, rxscan495_done + rxscan495_scan: + set_addr $I10, rxscan495_loop rx489_cur."!mark_push"(0, rx489_pos, $I10) - rxscan494_done: - alt495_0: -.annotate 'line', 246 - set_addr $I10, alt495_1 - rx489_cur."!mark_push"(0, rx489_pos, $I10) -.annotate 'line', 247 - # rx subrule "sigil" subtype=capture negate= - rx489_cur."!cursor_pos"(rx489_pos) - $P10 = rx489_cur."sigil"() - unless $P10, rx489_fail + rxscan495_done: +.annotate 'line', 240 + # rx literal ":" + add $I11, rx489_pos, 1 + gt $I11, rx489_eos, rx489_fail + sub $I11, rx489_pos, rx489_off + substr $S10, rx489_tgt, $I11, 1 + ne $S10, ":", rx489_fail + add rx489_pos, 1 + alt496_0: +.annotate 'line', 241 + set_addr $I10, alt496_1 + rx489_cur."!mark_push"(0, rx489_pos, $I10) +.annotate 'line', 242 + # rx subcapture "not" + set_addr $I10, rxcap_497_fail + rx489_cur."!mark_push"(0, rx489_pos, $I10) + # rx literal "!" + add $I11, rx489_pos, 1 + gt $I11, rx489_eos, rx489_fail + sub $I11, rx489_pos, rx489_off + substr $S10, rx489_tgt, $I11, 1 + ne $S10, "!", rx489_fail + add rx489_pos, 1 + set_addr $I10, rxcap_497_fail + ($I12, $I11) = rx489_cur."!mark_peek"($I10) + rx489_cur."!cursor_pos"($I11) + ($P10) = rx489_cur."!cursor_start"() + $P10."!cursor_pass"(rx489_pos, "") rx489_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("sigil") - rx489_pos = $P10."pos"() - # rx rxquantr496 ** 0..1 - set_addr $I497, rxquantr496_done - rx489_cur."!mark_push"(0, rx489_pos, $I497) - rxquantr496_loop: - # rx subrule "twigil" subtype=capture negate= + $P10."!cursor_names"("not") + goto rxcap_497_done + rxcap_497_fail: + goto rx489_fail + rxcap_497_done: + # rx subrule "identifier" subtype=capture negate= rx489_cur."!cursor_pos"(rx489_pos) - $P10 = rx489_cur."twigil"() + $P10 = rx489_cur."identifier"() unless $P10, rx489_fail rx489_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("twigil") + $P10."!cursor_names"("identifier") rx489_pos = $P10."pos"() - (rx489_rep) = rx489_cur."!mark_commit"($I497) - rxquantr496_done: - # rx subrule "name" subtype=capture negate= + goto alt496_end + alt496_1: + set_addr $I10, alt496_2 + rx489_cur."!mark_push"(0, rx489_pos, $I10) +.annotate 'line', 243 + # rx subrule "identifier" subtype=capture negate= rx489_cur."!cursor_pos"(rx489_pos) - $P10 = rx489_cur."name"() + $P10 = rx489_cur."identifier"() unless $P10, rx489_fail rx489_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("desigilname") + $P10."!cursor_names"("identifier") rx489_pos = $P10."pos"() - goto alt495_end - alt495_1: - set_addr $I10, alt495_2 - rx489_cur."!mark_push"(0, rx489_pos, $I10) -.annotate 'line', 248 - # rx subrule "sigil" subtype=capture negate= + # rx rxquantr498 ** 0..1 + set_addr $I499, rxquantr498_done + rx489_cur."!mark_push"(0, rx489_pos, $I499) + rxquantr498_loop: + # rx subrule "circumfix" subtype=capture negate= rx489_cur."!cursor_pos"(rx489_pos) - $P10 = rx489_cur."sigil"() + $P10 = rx489_cur."circumfix"() unless $P10, rx489_fail rx489_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("sigil") + $P10."!cursor_names"("circumfix") rx489_pos = $P10."pos"() - # rx enumcharlist negate=0 zerowidth - ge rx489_pos, rx489_eos, rx489_fail - sub $I10, rx489_pos, rx489_off - substr $S10, rx489_tgt, $I10, 1 - index $I11, "<[", $S10 - lt $I11, 0, rx489_fail - # rx subrule "postcircumfix" subtype=capture negate= + (rx489_rep) = rx489_cur."!mark_commit"($I499) + rxquantr498_done: + goto alt496_end + alt496_2: +.annotate 'line', 244 + # rx subrule "circumfix" subtype=capture negate= rx489_cur."!cursor_pos"(rx489_pos) - $P10 = rx489_cur."postcircumfix"() + $P10 = rx489_cur."circumfix"() unless $P10, rx489_fail rx489_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("postcircumfix") + $P10."!cursor_names"("circumfix") rx489_pos = $P10."pos"() - goto alt495_end - alt495_2: -.annotate 'line', 249 - # rx subcapture "sigil" - set_addr $I10, rxcap_498_fail - rx489_cur."!mark_push"(0, rx489_pos, $I10) - # rx literal "$" - add $I11, rx489_pos, 1 - gt $I11, rx489_eos, rx489_fail - sub $I11, rx489_pos, rx489_off - substr $S10, rx489_tgt, $I11, 1 - ne $S10, "$", rx489_fail - add rx489_pos, 1 - set_addr $I10, rxcap_498_fail - ($I12, $I11) = rx489_cur."!mark_peek"($I10) - rx489_cur."!cursor_pos"($I11) - ($P10) = rx489_cur."!cursor_start"() - $P10."!cursor_pass"(rx489_pos, "") - rx489_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("sigil") - goto rxcap_498_done - rxcap_498_fail: - goto rx489_fail - rxcap_498_done: - # rx subcapture "desigilname" - set_addr $I10, rxcap_499_fail - rx489_cur."!mark_push"(0, rx489_pos, $I10) - # rx enumcharlist negate=0 - ge rx489_pos, rx489_eos, rx489_fail - sub $I10, rx489_pos, rx489_off - substr $S10, rx489_tgt, $I10, 1 - index $I11, "/_!", $S10 - lt $I11, 0, rx489_fail - inc rx489_pos - set_addr $I10, rxcap_499_fail - ($I12, $I11) = rx489_cur."!mark_peek"($I10) - rx489_cur."!cursor_pos"($I11) - ($P10) = rx489_cur."!cursor_start"() - $P10."!cursor_pass"(rx489_pos, "") - rx489_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("desigilname") - goto rxcap_499_done - rxcap_499_fail: - goto rx489_fail - rxcap_499_done: - alt495_end: -.annotate 'line', 246 + alt496_end: +.annotate 'line', 239 # rx pass - rx489_cur."!cursor_pass"(rx489_pos, "variable") - rx489_cur."!cursor_debug"("PASS ", "variable", " at pos=", rx489_pos) + rx489_cur."!cursor_pass"(rx489_pos, "colonpair") + rx489_cur."!cursor_debug"("PASS ", "colonpair", " at pos=", rx489_pos) .return (rx489_cur) rx489_fail: .annotate 'line', 4 @@ -6178,29 +6178,28 @@ NQP::Compiler - NQP compiler jump $I10 rx489_done: rx489_cur."!cursor_fail"() - rx489_cur."!cursor_debug"("FAIL ", "variable") + rx489_cur."!cursor_debug"("FAIL ", "colonpair") .return (rx489_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__variable" :subid("120_1275511697.61926") :method +.sub "!PREFIX__colonpair" :subid("121_1275600007.84296") :method .annotate 'line', 4 - $P491 = self."!PREFIX__!subrule"("sigil", "") - $P492 = self."!PREFIX__!subrule"("sigil", "") - new $P493, "ResizablePMCArray" - push $P493, "$!" - push $P493, "$_" - push $P493, "$/" - push $P493, $P491 - push $P493, $P492 - .return ($P493) + $P491 = self."!PREFIX__!subrule"("circumfix", ":") + $P492 = self."!PREFIX__!subrule"("identifier", ":") + $P493 = self."!PREFIX__!subrule"("identifier", ":!") + new $P494, "ResizablePMCArray" + push $P494, $P491 + push $P494, $P492 + push $P494, $P493 + .return ($P494) .end .namespace ["NQP";"Grammar"] -.sub "sigil" :subid("121_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "variable" :subid("122_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 .local string rx501_tgt .local int rx501_pos @@ -6209,7 +6208,8 @@ NQP::Compiler - NQP compiler .local int rx501_rep .local pmc rx501_cur (rx501_cur, rx501_pos, rx501_tgt) = self."!cursor_start"() - rx501_cur."!cursor_debug"("START ", "sigil") + rx501_cur."!cursor_debug"("START ", "variable") + rx501_cur."!cursor_caparray"("twigil") .lex unicode:"$\x{a2}", rx501_cur .local pmc match .lex "$/", match @@ -6221,28 +6221,124 @@ NQP::Compiler - NQP compiler substr rx501_tgt, rx501_tgt, rx501_off rx501_start: $I10 = self.'from'() - ne $I10, -1, rxscan504_done - goto rxscan504_scan - rxscan504_loop: + ne $I10, -1, rxscan506_done + goto rxscan506_scan + rxscan506_loop: ($P10) = rx501_cur."from"() inc $P10 set rx501_pos, $P10 - ge rx501_pos, rx501_eos, rxscan504_done - rxscan504_scan: - set_addr $I10, rxscan504_loop + ge rx501_pos, rx501_eos, rxscan506_done + rxscan506_scan: + set_addr $I10, rxscan506_loop + rx501_cur."!mark_push"(0, rx501_pos, $I10) + rxscan506_done: + alt507_0: +.annotate 'line', 248 + set_addr $I10, alt507_1 + rx501_cur."!mark_push"(0, rx501_pos, $I10) +.annotate 'line', 249 + # rx subrule "sigil" subtype=capture negate= + rx501_cur."!cursor_pos"(rx501_pos) + $P10 = rx501_cur."sigil"() + unless $P10, rx501_fail + rx501_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("sigil") + rx501_pos = $P10."pos"() + # rx rxquantr508 ** 0..1 + set_addr $I509, rxquantr508_done + rx501_cur."!mark_push"(0, rx501_pos, $I509) + rxquantr508_loop: + # rx subrule "twigil" subtype=capture negate= + rx501_cur."!cursor_pos"(rx501_pos) + $P10 = rx501_cur."twigil"() + unless $P10, rx501_fail + rx501_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("twigil") + rx501_pos = $P10."pos"() + (rx501_rep) = rx501_cur."!mark_commit"($I509) + rxquantr508_done: + # rx subrule "name" subtype=capture negate= + rx501_cur."!cursor_pos"(rx501_pos) + $P10 = rx501_cur."name"() + unless $P10, rx501_fail + rx501_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("desigilname") + rx501_pos = $P10."pos"() + goto alt507_end + alt507_1: + set_addr $I10, alt507_2 + rx501_cur."!mark_push"(0, rx501_pos, $I10) +.annotate 'line', 250 + # rx subrule "sigil" subtype=capture negate= + rx501_cur."!cursor_pos"(rx501_pos) + $P10 = rx501_cur."sigil"() + unless $P10, rx501_fail + rx501_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("sigil") + rx501_pos = $P10."pos"() + # rx enumcharlist negate=0 zerowidth + ge rx501_pos, rx501_eos, rx501_fail + sub $I10, rx501_pos, rx501_off + substr $S10, rx501_tgt, $I10, 1 + index $I11, "<[", $S10 + lt $I11, 0, rx501_fail + # rx subrule "postcircumfix" subtype=capture negate= + rx501_cur."!cursor_pos"(rx501_pos) + $P10 = rx501_cur."postcircumfix"() + unless $P10, rx501_fail + rx501_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("postcircumfix") + rx501_pos = $P10."pos"() + goto alt507_end + alt507_2: +.annotate 'line', 251 + # rx subcapture "sigil" + set_addr $I10, rxcap_510_fail + rx501_cur."!mark_push"(0, rx501_pos, $I10) + # rx literal "$" + add $I11, rx501_pos, 1 + gt $I11, rx501_eos, rx501_fail + sub $I11, rx501_pos, rx501_off + substr $S10, rx501_tgt, $I11, 1 + ne $S10, "$", rx501_fail + add rx501_pos, 1 + set_addr $I10, rxcap_510_fail + ($I12, $I11) = rx501_cur."!mark_peek"($I10) + rx501_cur."!cursor_pos"($I11) + ($P10) = rx501_cur."!cursor_start"() + $P10."!cursor_pass"(rx501_pos, "") + rx501_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("sigil") + goto rxcap_510_done + rxcap_510_fail: + goto rx501_fail + rxcap_510_done: + # rx subcapture "desigilname" + set_addr $I10, rxcap_511_fail rx501_cur."!mark_push"(0, rx501_pos, $I10) - rxscan504_done: -.annotate 'line', 252 # rx enumcharlist negate=0 ge rx501_pos, rx501_eos, rx501_fail sub $I10, rx501_pos, rx501_off substr $S10, rx501_tgt, $I10, 1 - index $I11, "$@%&", $S10 + index $I11, "/_!", $S10 lt $I11, 0, rx501_fail inc rx501_pos + set_addr $I10, rxcap_511_fail + ($I12, $I11) = rx501_cur."!mark_peek"($I10) + rx501_cur."!cursor_pos"($I11) + ($P10) = rx501_cur."!cursor_start"() + $P10."!cursor_pass"(rx501_pos, "") + rx501_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("desigilname") + goto rxcap_511_done + rxcap_511_fail: + goto rx501_fail + rxcap_511_done: + alt507_end: +.annotate 'line', 248 # rx pass - rx501_cur."!cursor_pass"(rx501_pos, "sigil") - rx501_cur."!cursor_debug"("PASS ", "sigil", " at pos=", rx501_pos) + rx501_cur."!cursor_pass"(rx501_pos, "variable") + rx501_cur."!cursor_debug"("PASS ", "variable", " at pos=", rx501_pos) .return (rx501_cur) rx501_fail: .annotate 'line', 4 @@ -6252,5497 +6348,5360 @@ NQP::Compiler - NQP compiler jump $I10 rx501_done: rx501_cur."!cursor_fail"() - rx501_cur."!cursor_debug"("FAIL ", "sigil") + rx501_cur."!cursor_debug"("FAIL ", "variable") .return (rx501_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__sigil" :subid("122_1275511697.61926") :method +.sub "!PREFIX__variable" :subid("123_1275600007.84296") :method .annotate 'line', 4 - new $P503, "ResizablePMCArray" - push $P503, "&" - push $P503, "%" - push $P503, "@" - push $P503, "$" - .return ($P503) + $P503 = self."!PREFIX__!subrule"("sigil", "") + $P504 = self."!PREFIX__!subrule"("sigil", "") + new $P505, "ResizablePMCArray" + push $P505, "$!" + push $P505, "$_" + push $P505, "$/" + push $P505, $P503 + push $P505, $P504 + .return ($P505) .end .namespace ["NQP";"Grammar"] -.sub "twigil" :subid("123_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "sigil" :subid("124_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx506_tgt - .local int rx506_pos - .local int rx506_off - .local int rx506_eos - .local int rx506_rep - .local pmc rx506_cur - (rx506_cur, rx506_pos, rx506_tgt) = self."!cursor_start"() - rx506_cur."!cursor_debug"("START ", "twigil") - .lex unicode:"$\x{a2}", rx506_cur + .local string rx513_tgt + .local int rx513_pos + .local int rx513_off + .local int rx513_eos + .local int rx513_rep + .local pmc rx513_cur + (rx513_cur, rx513_pos, rx513_tgt) = self."!cursor_start"() + rx513_cur."!cursor_debug"("START ", "sigil") + .lex unicode:"$\x{a2}", rx513_cur .local pmc match .lex "$/", match - length rx506_eos, rx506_tgt - gt rx506_pos, rx506_eos, rx506_done - set rx506_off, 0 - lt rx506_pos, 2, rx506_start - sub rx506_off, rx506_pos, 1 - substr rx506_tgt, rx506_tgt, rx506_off - rx506_start: + length rx513_eos, rx513_tgt + gt rx513_pos, rx513_eos, rx513_done + set rx513_off, 0 + lt rx513_pos, 2, rx513_start + sub rx513_off, rx513_pos, 1 + substr rx513_tgt, rx513_tgt, rx513_off + rx513_start: $I10 = self.'from'() - ne $I10, -1, rxscan509_done - goto rxscan509_scan - rxscan509_loop: - ($P10) = rx506_cur."from"() + ne $I10, -1, rxscan516_done + goto rxscan516_scan + rxscan516_loop: + ($P10) = rx513_cur."from"() inc $P10 - set rx506_pos, $P10 - ge rx506_pos, rx506_eos, rxscan509_done - rxscan509_scan: - set_addr $I10, rxscan509_loop - rx506_cur."!mark_push"(0, rx506_pos, $I10) - rxscan509_done: + set rx513_pos, $P10 + ge rx513_pos, rx513_eos, rxscan516_done + rxscan516_scan: + set_addr $I10, rxscan516_loop + rx513_cur."!mark_push"(0, rx513_pos, $I10) + rxscan516_done: .annotate 'line', 254 # rx enumcharlist negate=0 - ge rx506_pos, rx506_eos, rx506_fail - sub $I10, rx506_pos, rx506_off - substr $S10, rx506_tgt, $I10, 1 - index $I11, "*!?", $S10 - lt $I11, 0, rx506_fail - inc rx506_pos + ge rx513_pos, rx513_eos, rx513_fail + sub $I10, rx513_pos, rx513_off + substr $S10, rx513_tgt, $I10, 1 + index $I11, "$@%&", $S10 + lt $I11, 0, rx513_fail + inc rx513_pos # rx pass - rx506_cur."!cursor_pass"(rx506_pos, "twigil") - rx506_cur."!cursor_debug"("PASS ", "twigil", " at pos=", rx506_pos) - .return (rx506_cur) - rx506_fail: -.annotate 'line', 4 - (rx506_rep, rx506_pos, $I10, $P10) = rx506_cur."!mark_fail"(0) - lt rx506_pos, -1, rx506_done - eq rx506_pos, -1, rx506_fail + rx513_cur."!cursor_pass"(rx513_pos, "sigil") + rx513_cur."!cursor_debug"("PASS ", "sigil", " at pos=", rx513_pos) + .return (rx513_cur) + rx513_fail: +.annotate 'line', 4 + (rx513_rep, rx513_pos, $I10, $P10) = rx513_cur."!mark_fail"(0) + lt rx513_pos, -1, rx513_done + eq rx513_pos, -1, rx513_fail jump $I10 - rx506_done: - rx506_cur."!cursor_fail"() - rx506_cur."!cursor_debug"("FAIL ", "twigil") - .return (rx506_cur) + rx513_done: + rx513_cur."!cursor_fail"() + rx513_cur."!cursor_debug"("FAIL ", "sigil") + .return (rx513_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__twigil" :subid("124_1275511697.61926") :method +.sub "!PREFIX__sigil" :subid("125_1275600007.84296") :method .annotate 'line', 4 - new $P508, "ResizablePMCArray" - push $P508, "?" - push $P508, "!" - push $P508, "*" - .return ($P508) + new $P515, "ResizablePMCArray" + push $P515, "&" + push $P515, "%" + push $P515, "@" + push $P515, "$" + .return ($P515) .end .namespace ["NQP";"Grammar"] -.sub "package_declarator" :subid("125_1275511697.61926") :method +.sub "twigil" :subid("126_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 4 + .local string rx518_tgt + .local int rx518_pos + .local int rx518_off + .local int rx518_eos + .local int rx518_rep + .local pmc rx518_cur + (rx518_cur, rx518_pos, rx518_tgt) = self."!cursor_start"() + rx518_cur."!cursor_debug"("START ", "twigil") + .lex unicode:"$\x{a2}", rx518_cur + .local pmc match + .lex "$/", match + length rx518_eos, rx518_tgt + gt rx518_pos, rx518_eos, rx518_done + set rx518_off, 0 + lt rx518_pos, 2, rx518_start + sub rx518_off, rx518_pos, 1 + substr rx518_tgt, rx518_tgt, rx518_off + rx518_start: + $I10 = self.'from'() + ne $I10, -1, rxscan521_done + goto rxscan521_scan + rxscan521_loop: + ($P10) = rx518_cur."from"() + inc $P10 + set rx518_pos, $P10 + ge rx518_pos, rx518_eos, rxscan521_done + rxscan521_scan: + set_addr $I10, rxscan521_loop + rx518_cur."!mark_push"(0, rx518_pos, $I10) + rxscan521_done: .annotate 'line', 256 - $P511 = self."!protoregex"("package_declarator") - .return ($P511) + # rx enumcharlist negate=0 + ge rx518_pos, rx518_eos, rx518_fail + sub $I10, rx518_pos, rx518_off + substr $S10, rx518_tgt, $I10, 1 + index $I11, "*!?", $S10 + lt $I11, 0, rx518_fail + inc rx518_pos + # rx pass + rx518_cur."!cursor_pass"(rx518_pos, "twigil") + rx518_cur."!cursor_debug"("PASS ", "twigil", " at pos=", rx518_pos) + .return (rx518_cur) + rx518_fail: +.annotate 'line', 4 + (rx518_rep, rx518_pos, $I10, $P10) = rx518_cur."!mark_fail"(0) + lt rx518_pos, -1, rx518_done + eq rx518_pos, -1, rx518_fail + jump $I10 + rx518_done: + rx518_cur."!cursor_fail"() + rx518_cur."!cursor_debug"("FAIL ", "twigil") + .return (rx518_cur) + .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__package_declarator" :subid("126_1275511697.61926") :method -.annotate 'line', 256 - $P513 = self."!PREFIX__!protoregex"("package_declarator") - .return ($P513) +.sub "!PREFIX__twigil" :subid("127_1275600007.84296") :method +.annotate 'line', 4 + new $P520, "ResizablePMCArray" + push $P520, "?" + push $P520, "!" + push $P520, "*" + .return ($P520) +.end + + +.namespace ["NQP";"Grammar"] +.sub "package_declarator" :subid("128_1275600007.84296") :method +.annotate 'line', 258 + $P523 = self."!protoregex"("package_declarator") + .return ($P523) +.end + + +.namespace ["NQP";"Grammar"] +.sub "!PREFIX__package_declarator" :subid("129_1275600007.84296") :method +.annotate 'line', 258 + $P525 = self."!PREFIX__!protoregex"("package_declarator") + .return ($P525) .end .namespace ["NQP";"Grammar"] -.sub "package_declarator:sym" :subid("127_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "package_declarator:sym" :subid("130_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx515_tgt - .local int rx515_pos - .local int rx515_off - .local int rx515_eos - .local int rx515_rep - .local pmc rx515_cur - (rx515_cur, rx515_pos, rx515_tgt) = self."!cursor_start"() - rx515_cur."!cursor_debug"("START ", "package_declarator:sym") - .lex unicode:"$\x{a2}", rx515_cur + .local string rx527_tgt + .local int rx527_pos + .local int rx527_off + .local int rx527_eos + .local int rx527_rep + .local pmc rx527_cur + (rx527_cur, rx527_pos, rx527_tgt) = self."!cursor_start"() + rx527_cur."!cursor_debug"("START ", "package_declarator:sym") + .lex unicode:"$\x{a2}", rx527_cur .local pmc match .lex "$/", match - length rx515_eos, rx515_tgt - gt rx515_pos, rx515_eos, rx515_done - set rx515_off, 0 - lt rx515_pos, 2, rx515_start - sub rx515_off, rx515_pos, 1 - substr rx515_tgt, rx515_tgt, rx515_off - rx515_start: + length rx527_eos, rx527_tgt + gt rx527_pos, rx527_eos, rx527_done + set rx527_off, 0 + lt rx527_pos, 2, rx527_start + sub rx527_off, rx527_pos, 1 + substr rx527_tgt, rx527_tgt, rx527_off + rx527_start: $I10 = self.'from'() - ne $I10, -1, rxscan519_done - goto rxscan519_scan - rxscan519_loop: - ($P10) = rx515_cur."from"() + ne $I10, -1, rxscan531_done + goto rxscan531_scan + rxscan531_loop: + ($P10) = rx527_cur."from"() inc $P10 - set rx515_pos, $P10 - ge rx515_pos, rx515_eos, rxscan519_done - rxscan519_scan: - set_addr $I10, rxscan519_loop - rx515_cur."!mark_push"(0, rx515_pos, $I10) - rxscan519_done: -.annotate 'line', 257 + set rx527_pos, $P10 + ge rx527_pos, rx527_eos, rxscan531_done + rxscan531_scan: + set_addr $I10, rxscan531_loop + rx527_cur."!mark_push"(0, rx527_pos, $I10) + rxscan531_done: +.annotate 'line', 259 # rx subcapture "sym" - set_addr $I10, rxcap_520_fail - rx515_cur."!mark_push"(0, rx515_pos, $I10) + set_addr $I10, rxcap_532_fail + rx527_cur."!mark_push"(0, rx527_pos, $I10) # rx literal "module" - add $I11, rx515_pos, 6 - gt $I11, rx515_eos, rx515_fail - sub $I11, rx515_pos, rx515_off - substr $S10, rx515_tgt, $I11, 6 - ne $S10, "module", rx515_fail - add rx515_pos, 6 - set_addr $I10, rxcap_520_fail - ($I12, $I11) = rx515_cur."!mark_peek"($I10) - rx515_cur."!cursor_pos"($I11) - ($P10) = rx515_cur."!cursor_start"() - $P10."!cursor_pass"(rx515_pos, "") - rx515_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx527_pos, 6 + gt $I11, rx527_eos, rx527_fail + sub $I11, rx527_pos, rx527_off + substr $S10, rx527_tgt, $I11, 6 + ne $S10, "module", rx527_fail + add rx527_pos, 6 + set_addr $I10, rxcap_532_fail + ($I12, $I11) = rx527_cur."!mark_peek"($I10) + rx527_cur."!cursor_pos"($I11) + ($P10) = rx527_cur."!cursor_start"() + $P10."!cursor_pass"(rx527_pos, "") + rx527_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_520_done - rxcap_520_fail: - goto rx515_fail - rxcap_520_done: + goto rxcap_532_done + rxcap_532_fail: + goto rx527_fail + rxcap_532_done: # rx subrule "package_def" subtype=capture negate= - rx515_cur."!cursor_pos"(rx515_pos) - $P10 = rx515_cur."package_def"() - unless $P10, rx515_fail - rx515_cur."!mark_push"(0, -1, 0, $P10) + rx527_cur."!cursor_pos"(rx527_pos) + $P10 = rx527_cur."package_def"() + unless $P10, rx527_fail + rx527_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("package_def") - rx515_pos = $P10."pos"() + rx527_pos = $P10."pos"() # rx pass - rx515_cur."!cursor_pass"(rx515_pos, "package_declarator:sym") - rx515_cur."!cursor_debug"("PASS ", "package_declarator:sym", " at pos=", rx515_pos) - .return (rx515_cur) - rx515_fail: -.annotate 'line', 4 - (rx515_rep, rx515_pos, $I10, $P10) = rx515_cur."!mark_fail"(0) - lt rx515_pos, -1, rx515_done - eq rx515_pos, -1, rx515_fail + rx527_cur."!cursor_pass"(rx527_pos, "package_declarator:sym") + rx527_cur."!cursor_debug"("PASS ", "package_declarator:sym", " at pos=", rx527_pos) + .return (rx527_cur) + rx527_fail: +.annotate 'line', 4 + (rx527_rep, rx527_pos, $I10, $P10) = rx527_cur."!mark_fail"(0) + lt rx527_pos, -1, rx527_done + eq rx527_pos, -1, rx527_fail jump $I10 - rx515_done: - rx515_cur."!cursor_fail"() - rx515_cur."!cursor_debug"("FAIL ", "package_declarator:sym") - .return (rx515_cur) + rx527_done: + rx527_cur."!cursor_fail"() + rx527_cur."!cursor_debug"("FAIL ", "package_declarator:sym") + .return (rx527_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__package_declarator:sym" :subid("128_1275511697.61926") :method +.sub "!PREFIX__package_declarator:sym" :subid("131_1275600007.84296") :method .annotate 'line', 4 - $P517 = self."!PREFIX__!subrule"("package_def", "module") - new $P518, "ResizablePMCArray" - push $P518, $P517 - .return ($P518) + $P529 = self."!PREFIX__!subrule"("package_def", "module") + new $P530, "ResizablePMCArray" + push $P530, $P529 + .return ($P530) .end .namespace ["NQP";"Grammar"] -.sub "package_declarator:sym" :subid("129_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "package_declarator:sym" :subid("132_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx522_tgt - .local int rx522_pos - .local int rx522_off - .local int rx522_eos - .local int rx522_rep - .local pmc rx522_cur - (rx522_cur, rx522_pos, rx522_tgt) = self."!cursor_start"() - rx522_cur."!cursor_debug"("START ", "package_declarator:sym") - .lex unicode:"$\x{a2}", rx522_cur + .local string rx534_tgt + .local int rx534_pos + .local int rx534_off + .local int rx534_eos + .local int rx534_rep + .local pmc rx534_cur + (rx534_cur, rx534_pos, rx534_tgt) = self."!cursor_start"() + rx534_cur."!cursor_debug"("START ", "package_declarator:sym") + .lex unicode:"$\x{a2}", rx534_cur .local pmc match .lex "$/", match - length rx522_eos, rx522_tgt - gt rx522_pos, rx522_eos, rx522_done - set rx522_off, 0 - lt rx522_pos, 2, rx522_start - sub rx522_off, rx522_pos, 1 - substr rx522_tgt, rx522_tgt, rx522_off - rx522_start: + length rx534_eos, rx534_tgt + gt rx534_pos, rx534_eos, rx534_done + set rx534_off, 0 + lt rx534_pos, 2, rx534_start + sub rx534_off, rx534_pos, 1 + substr rx534_tgt, rx534_tgt, rx534_off + rx534_start: $I10 = self.'from'() - ne $I10, -1, rxscan527_done - goto rxscan527_scan - rxscan527_loop: - ($P10) = rx522_cur."from"() + ne $I10, -1, rxscan539_done + goto rxscan539_scan + rxscan539_loop: + ($P10) = rx534_cur."from"() inc $P10 - set rx522_pos, $P10 - ge rx522_pos, rx522_eos, rxscan527_done - rxscan527_scan: - set_addr $I10, rxscan527_loop - rx522_cur."!mark_push"(0, rx522_pos, $I10) - rxscan527_done: -.annotate 'line', 258 + set rx534_pos, $P10 + ge rx534_pos, rx534_eos, rxscan539_done + rxscan539_scan: + set_addr $I10, rxscan539_loop + rx534_cur."!mark_push"(0, rx534_pos, $I10) + rxscan539_done: +.annotate 'line', 260 # rx subcapture "sym" - set_addr $I10, rxcap_529_fail - rx522_cur."!mark_push"(0, rx522_pos, $I10) - alt528_0: - set_addr $I10, alt528_1 - rx522_cur."!mark_push"(0, rx522_pos, $I10) + set_addr $I10, rxcap_541_fail + rx534_cur."!mark_push"(0, rx534_pos, $I10) + alt540_0: + set_addr $I10, alt540_1 + rx534_cur."!mark_push"(0, rx534_pos, $I10) # rx literal "class" - add $I11, rx522_pos, 5 - gt $I11, rx522_eos, rx522_fail - sub $I11, rx522_pos, rx522_off - substr $S10, rx522_tgt, $I11, 5 - ne $S10, "class", rx522_fail - add rx522_pos, 5 - goto alt528_end - alt528_1: + add $I11, rx534_pos, 5 + gt $I11, rx534_eos, rx534_fail + sub $I11, rx534_pos, rx534_off + substr $S10, rx534_tgt, $I11, 5 + ne $S10, "class", rx534_fail + add rx534_pos, 5 + goto alt540_end + alt540_1: # rx literal "grammar" - add $I11, rx522_pos, 7 - gt $I11, rx522_eos, rx522_fail - sub $I11, rx522_pos, rx522_off - substr $S10, rx522_tgt, $I11, 7 - ne $S10, "grammar", rx522_fail - add rx522_pos, 7 - alt528_end: - set_addr $I10, rxcap_529_fail - ($I12, $I11) = rx522_cur."!mark_peek"($I10) - rx522_cur."!cursor_pos"($I11) - ($P10) = rx522_cur."!cursor_start"() - $P10."!cursor_pass"(rx522_pos, "") - rx522_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx534_pos, 7 + gt $I11, rx534_eos, rx534_fail + sub $I11, rx534_pos, rx534_off + substr $S10, rx534_tgt, $I11, 7 + ne $S10, "grammar", rx534_fail + add rx534_pos, 7 + alt540_end: + set_addr $I10, rxcap_541_fail + ($I12, $I11) = rx534_cur."!mark_peek"($I10) + rx534_cur."!cursor_pos"($I11) + ($P10) = rx534_cur."!cursor_start"() + $P10."!cursor_pass"(rx534_pos, "") + rx534_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_529_done - rxcap_529_fail: - goto rx522_fail - rxcap_529_done: + goto rxcap_541_done + rxcap_541_fail: + goto rx534_fail + rxcap_541_done: # rx subrule "package_def" subtype=capture negate= - rx522_cur."!cursor_pos"(rx522_pos) - $P10 = rx522_cur."package_def"() - unless $P10, rx522_fail - rx522_cur."!mark_push"(0, -1, 0, $P10) + rx534_cur."!cursor_pos"(rx534_pos) + $P10 = rx534_cur."package_def"() + unless $P10, rx534_fail + rx534_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("package_def") - rx522_pos = $P10."pos"() + rx534_pos = $P10."pos"() # rx pass - rx522_cur."!cursor_pass"(rx522_pos, "package_declarator:sym") - rx522_cur."!cursor_debug"("PASS ", "package_declarator:sym", " at pos=", rx522_pos) - .return (rx522_cur) - rx522_fail: -.annotate 'line', 4 - (rx522_rep, rx522_pos, $I10, $P10) = rx522_cur."!mark_fail"(0) - lt rx522_pos, -1, rx522_done - eq rx522_pos, -1, rx522_fail + rx534_cur."!cursor_pass"(rx534_pos, "package_declarator:sym") + rx534_cur."!cursor_debug"("PASS ", "package_declarator:sym", " at pos=", rx534_pos) + .return (rx534_cur) + rx534_fail: +.annotate 'line', 4 + (rx534_rep, rx534_pos, $I10, $P10) = rx534_cur."!mark_fail"(0) + lt rx534_pos, -1, rx534_done + eq rx534_pos, -1, rx534_fail jump $I10 - rx522_done: - rx522_cur."!cursor_fail"() - rx522_cur."!cursor_debug"("FAIL ", "package_declarator:sym") - .return (rx522_cur) + rx534_done: + rx534_cur."!cursor_fail"() + rx534_cur."!cursor_debug"("FAIL ", "package_declarator:sym") + .return (rx534_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__package_declarator:sym" :subid("130_1275511697.61926") :method +.sub "!PREFIX__package_declarator:sym" :subid("133_1275600007.84296") :method .annotate 'line', 4 - $P524 = self."!PREFIX__!subrule"("package_def", "grammar") - $P525 = self."!PREFIX__!subrule"("package_def", "class") - new $P526, "ResizablePMCArray" - push $P526, $P524 - push $P526, $P525 - .return ($P526) + $P536 = self."!PREFIX__!subrule"("package_def", "grammar") + $P537 = self."!PREFIX__!subrule"("package_def", "class") + new $P538, "ResizablePMCArray" + push $P538, $P536 + push $P538, $P537 + .return ($P538) .end .namespace ["NQP";"Grammar"] -.sub "package_def" :subid("131_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "package_def" :subid("134_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx531_tgt - .local int rx531_pos - .local int rx531_off - .local int rx531_eos - .local int rx531_rep - .local pmc rx531_cur - (rx531_cur, rx531_pos, rx531_tgt) = self."!cursor_start"() - rx531_cur."!cursor_debug"("START ", "package_def") - rx531_cur."!cursor_caparray"("parent") - .lex unicode:"$\x{a2}", rx531_cur + .local string rx543_tgt + .local int rx543_pos + .local int rx543_off + .local int rx543_eos + .local int rx543_rep + .local pmc rx543_cur + (rx543_cur, rx543_pos, rx543_tgt) = self."!cursor_start"() + rx543_cur."!cursor_debug"("START ", "package_def") + rx543_cur."!cursor_caparray"("parent") + .lex unicode:"$\x{a2}", rx543_cur .local pmc match .lex "$/", match - length rx531_eos, rx531_tgt - gt rx531_pos, rx531_eos, rx531_done - set rx531_off, 0 - lt rx531_pos, 2, rx531_start - sub rx531_off, rx531_pos, 1 - substr rx531_tgt, rx531_tgt, rx531_off - rx531_start: + length rx543_eos, rx543_tgt + gt rx543_pos, rx543_eos, rx543_done + set rx543_off, 0 + lt rx543_pos, 2, rx543_start + sub rx543_off, rx543_pos, 1 + substr rx543_tgt, rx543_tgt, rx543_off + rx543_start: $I10 = self.'from'() - ne $I10, -1, rxscan534_done - goto rxscan534_scan - rxscan534_loop: - ($P10) = rx531_cur."from"() + ne $I10, -1, rxscan546_done + goto rxscan546_scan + rxscan546_loop: + ($P10) = rx543_cur."from"() inc $P10 - set rx531_pos, $P10 - ge rx531_pos, rx531_eos, rxscan534_done - rxscan534_scan: - set_addr $I10, rxscan534_loop - rx531_cur."!mark_push"(0, rx531_pos, $I10) - rxscan534_done: -.annotate 'line', 260 + set rx543_pos, $P10 + ge rx543_pos, rx543_eos, rxscan546_done + rxscan546_scan: + set_addr $I10, rxscan546_loop + rx543_cur."!mark_push"(0, rx543_pos, $I10) + rxscan546_done: +.annotate 'line', 262 # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() -.annotate 'line', 261 + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() +.annotate 'line', 263 # rx subrule "name" subtype=capture negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."name"() - unless $P10, rx531_fail - rx531_cur."!mark_push"(0, -1, 0, $P10) + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."name"() + unless $P10, rx543_fail + rx543_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("name") - rx531_pos = $P10."pos"() + rx543_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() -.annotate 'line', 262 - # rx rxquantr537 ** 0..1 - set_addr $I541, rxquantr537_done - rx531_cur."!mark_push"(0, rx531_pos, $I541) - rxquantr537_loop: + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() +.annotate 'line', 264 + # rx rxquantr549 ** 0..1 + set_addr $I553, rxquantr549_done + rx543_cur."!mark_push"(0, rx543_pos, $I553) + rxquantr549_loop: # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() # rx literal "is" - add $I11, rx531_pos, 2 - gt $I11, rx531_eos, rx531_fail - sub $I11, rx531_pos, rx531_off - substr $S10, rx531_tgt, $I11, 2 - ne $S10, "is", rx531_fail - add rx531_pos, 2 + add $I11, rx543_pos, 2 + gt $I11, rx543_eos, rx543_fail + sub $I11, rx543_pos, rx543_off + substr $S10, rx543_tgt, $I11, 2 + ne $S10, "is", rx543_fail + add rx543_pos, 2 # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() # rx subrule "name" subtype=capture negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."name"() - unless $P10, rx531_fail - rx531_cur."!mark_push"(0, -1, 0, $P10) + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."name"() + unless $P10, rx543_fail + rx543_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("parent") - rx531_pos = $P10."pos"() + rx543_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() - (rx531_rep) = rx531_cur."!mark_commit"($I541) - rxquantr537_done: + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() + (rx543_rep) = rx543_cur."!mark_commit"($I553) + rxquantr549_done: # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() - alt543_0: -.annotate 'line', 263 - set_addr $I10, alt543_1 - rx531_cur."!mark_push"(0, rx531_pos, $I10) -.annotate 'line', 264 + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() + alt555_0: +.annotate 'line', 265 + set_addr $I10, alt555_1 + rx543_cur."!mark_push"(0, rx543_pos, $I10) +.annotate 'line', 266 # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() # rx literal ";" - add $I11, rx531_pos, 1 - gt $I11, rx531_eos, rx531_fail - sub $I11, rx531_pos, rx531_off - substr $S10, rx531_tgt, $I11, 1 - ne $S10, ";", rx531_fail - add rx531_pos, 1 + add $I11, rx543_pos, 1 + gt $I11, rx543_eos, rx543_fail + sub $I11, rx543_pos, rx543_off + substr $S10, rx543_tgt, $I11, 1 + ne $S10, ";", rx543_fail + add rx543_pos, 1 # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() # rx subrule "comp_unit" subtype=capture negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."comp_unit"() - unless $P10, rx531_fail - rx531_cur."!mark_push"(0, -1, 0, $P10) + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."comp_unit"() + unless $P10, rx543_fail + rx543_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("comp_unit") - rx531_pos = $P10."pos"() + rx543_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() - goto alt543_end - alt543_1: - set_addr $I10, alt543_2 - rx531_cur."!mark_push"(0, rx531_pos, $I10) -.annotate 'line', 265 + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() + goto alt555_end + alt555_1: + set_addr $I10, alt555_2 + rx543_cur."!mark_push"(0, rx543_pos, $I10) +.annotate 'line', 267 # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() # rx enumcharlist negate=0 zerowidth - ge rx531_pos, rx531_eos, rx531_fail - sub $I10, rx531_pos, rx531_off - substr $S10, rx531_tgt, $I10, 1 + ge rx543_pos, rx543_eos, rx543_fail + sub $I10, rx543_pos, rx543_off + substr $S10, rx543_tgt, $I10, 1 index $I11, "{", $S10 - lt $I11, 0, rx531_fail + lt $I11, 0, rx543_fail # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() # rx subrule "block" subtype=capture negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."block"() - unless $P10, rx531_fail - rx531_cur."!mark_push"(0, -1, 0, $P10) + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."block"() + unless $P10, rx543_fail + rx543_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("block") - rx531_pos = $P10."pos"() + rx543_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() - goto alt543_end - alt543_2: -.annotate 'line', 266 + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() + goto alt555_end + alt555_2: +.annotate 'line', 268 # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() # rx subrule "panic" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."panic"("Malformed package declaration") - unless $P10, rx531_fail - rx531_pos = $P10."pos"() + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."panic"("Malformed package declaration") + unless $P10, rx543_fail + rx543_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() - alt543_end: -.annotate 'line', 267 + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() + alt555_end: +.annotate 'line', 269 # rx subrule "ws" subtype=method negate= - rx531_cur."!cursor_pos"(rx531_pos) - $P10 = rx531_cur."ws"() - unless $P10, rx531_fail - rx531_pos = $P10."pos"() -.annotate 'line', 260 + rx543_cur."!cursor_pos"(rx543_pos) + $P10 = rx543_cur."ws"() + unless $P10, rx543_fail + rx543_pos = $P10."pos"() +.annotate 'line', 262 # rx pass - rx531_cur."!cursor_pass"(rx531_pos, "package_def") - rx531_cur."!cursor_debug"("PASS ", "package_def", " at pos=", rx531_pos) - .return (rx531_cur) - rx531_fail: -.annotate 'line', 4 - (rx531_rep, rx531_pos, $I10, $P10) = rx531_cur."!mark_fail"(0) - lt rx531_pos, -1, rx531_done - eq rx531_pos, -1, rx531_fail + rx543_cur."!cursor_pass"(rx543_pos, "package_def") + rx543_cur."!cursor_debug"("PASS ", "package_def", " at pos=", rx543_pos) + .return (rx543_cur) + rx543_fail: +.annotate 'line', 4 + (rx543_rep, rx543_pos, $I10, $P10) = rx543_cur."!mark_fail"(0) + lt rx543_pos, -1, rx543_done + eq rx543_pos, -1, rx543_fail jump $I10 - rx531_done: - rx531_cur."!cursor_fail"() - rx531_cur."!cursor_debug"("FAIL ", "package_def") - .return (rx531_cur) + rx543_done: + rx543_cur."!cursor_fail"() + rx543_cur."!cursor_debug"("FAIL ", "package_def") + .return (rx543_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__package_def" :subid("132_1275511697.61926") :method +.sub "!PREFIX__package_def" :subid("135_1275600007.84296") :method .annotate 'line', 4 - new $P533, "ResizablePMCArray" - push $P533, "" - .return ($P533) + new $P545, "ResizablePMCArray" + push $P545, "" + .return ($P545) .end .namespace ["NQP";"Grammar"] -.sub "scope_declarator" :subid("133_1275511697.61926") :method -.annotate 'line', 270 - $P554 = self."!protoregex"("scope_declarator") - .return ($P554) +.sub "scope_declarator" :subid("136_1275600007.84296") :method +.annotate 'line', 272 + $P566 = self."!protoregex"("scope_declarator") + .return ($P566) .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__scope_declarator" :subid("134_1275511697.61926") :method -.annotate 'line', 270 - $P556 = self."!PREFIX__!protoregex"("scope_declarator") - .return ($P556) +.sub "!PREFIX__scope_declarator" :subid("137_1275600007.84296") :method +.annotate 'line', 272 + $P568 = self."!PREFIX__!protoregex"("scope_declarator") + .return ($P568) .end .namespace ["NQP";"Grammar"] -.sub "scope_declarator:sym" :subid("135_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "scope_declarator:sym" :subid("138_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx558_tgt - .local int rx558_pos - .local int rx558_off - .local int rx558_eos - .local int rx558_rep - .local pmc rx558_cur - (rx558_cur, rx558_pos, rx558_tgt) = self."!cursor_start"() - rx558_cur."!cursor_debug"("START ", "scope_declarator:sym") - .lex unicode:"$\x{a2}", rx558_cur + .local string rx570_tgt + .local int rx570_pos + .local int rx570_off + .local int rx570_eos + .local int rx570_rep + .local pmc rx570_cur + (rx570_cur, rx570_pos, rx570_tgt) = self."!cursor_start"() + rx570_cur."!cursor_debug"("START ", "scope_declarator:sym") + .lex unicode:"$\x{a2}", rx570_cur .local pmc match .lex "$/", match - length rx558_eos, rx558_tgt - gt rx558_pos, rx558_eos, rx558_done - set rx558_off, 0 - lt rx558_pos, 2, rx558_start - sub rx558_off, rx558_pos, 1 - substr rx558_tgt, rx558_tgt, rx558_off - rx558_start: + length rx570_eos, rx570_tgt + gt rx570_pos, rx570_eos, rx570_done + set rx570_off, 0 + lt rx570_pos, 2, rx570_start + sub rx570_off, rx570_pos, 1 + substr rx570_tgt, rx570_tgt, rx570_off + rx570_start: $I10 = self.'from'() - ne $I10, -1, rxscan562_done - goto rxscan562_scan - rxscan562_loop: - ($P10) = rx558_cur."from"() + ne $I10, -1, rxscan574_done + goto rxscan574_scan + rxscan574_loop: + ($P10) = rx570_cur."from"() inc $P10 - set rx558_pos, $P10 - ge rx558_pos, rx558_eos, rxscan562_done - rxscan562_scan: - set_addr $I10, rxscan562_loop - rx558_cur."!mark_push"(0, rx558_pos, $I10) - rxscan562_done: -.annotate 'line', 271 + set rx570_pos, $P10 + ge rx570_pos, rx570_eos, rxscan574_done + rxscan574_scan: + set_addr $I10, rxscan574_loop + rx570_cur."!mark_push"(0, rx570_pos, $I10) + rxscan574_done: +.annotate 'line', 273 # rx subcapture "sym" - set_addr $I10, rxcap_563_fail - rx558_cur."!mark_push"(0, rx558_pos, $I10) + set_addr $I10, rxcap_575_fail + rx570_cur."!mark_push"(0, rx570_pos, $I10) # rx literal "my" - add $I11, rx558_pos, 2 - gt $I11, rx558_eos, rx558_fail - sub $I11, rx558_pos, rx558_off - substr $S10, rx558_tgt, $I11, 2 - ne $S10, "my", rx558_fail - add rx558_pos, 2 - set_addr $I10, rxcap_563_fail - ($I12, $I11) = rx558_cur."!mark_peek"($I10) - rx558_cur."!cursor_pos"($I11) - ($P10) = rx558_cur."!cursor_start"() - $P10."!cursor_pass"(rx558_pos, "") - rx558_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx570_pos, 2 + gt $I11, rx570_eos, rx570_fail + sub $I11, rx570_pos, rx570_off + substr $S10, rx570_tgt, $I11, 2 + ne $S10, "my", rx570_fail + add rx570_pos, 2 + set_addr $I10, rxcap_575_fail + ($I12, $I11) = rx570_cur."!mark_peek"($I10) + rx570_cur."!cursor_pos"($I11) + ($P10) = rx570_cur."!cursor_start"() + $P10."!cursor_pass"(rx570_pos, "") + rx570_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_563_done - rxcap_563_fail: - goto rx558_fail - rxcap_563_done: + goto rxcap_575_done + rxcap_575_fail: + goto rx570_fail + rxcap_575_done: # rx subrule "scoped" subtype=capture negate= - rx558_cur."!cursor_pos"(rx558_pos) - $P10 = rx558_cur."scoped"("my") - unless $P10, rx558_fail - rx558_cur."!mark_push"(0, -1, 0, $P10) + rx570_cur."!cursor_pos"(rx570_pos) + $P10 = rx570_cur."scoped"("my") + unless $P10, rx570_fail + rx570_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("scoped") - rx558_pos = $P10."pos"() + rx570_pos = $P10."pos"() # rx pass - rx558_cur."!cursor_pass"(rx558_pos, "scope_declarator:sym") - rx558_cur."!cursor_debug"("PASS ", "scope_declarator:sym", " at pos=", rx558_pos) - .return (rx558_cur) - rx558_fail: -.annotate 'line', 4 - (rx558_rep, rx558_pos, $I10, $P10) = rx558_cur."!mark_fail"(0) - lt rx558_pos, -1, rx558_done - eq rx558_pos, -1, rx558_fail + rx570_cur."!cursor_pass"(rx570_pos, "scope_declarator:sym") + rx570_cur."!cursor_debug"("PASS ", "scope_declarator:sym", " at pos=", rx570_pos) + .return (rx570_cur) + rx570_fail: +.annotate 'line', 4 + (rx570_rep, rx570_pos, $I10, $P10) = rx570_cur."!mark_fail"(0) + lt rx570_pos, -1, rx570_done + eq rx570_pos, -1, rx570_fail jump $I10 - rx558_done: - rx558_cur."!cursor_fail"() - rx558_cur."!cursor_debug"("FAIL ", "scope_declarator:sym") - .return (rx558_cur) + rx570_done: + rx570_cur."!cursor_fail"() + rx570_cur."!cursor_debug"("FAIL ", "scope_declarator:sym") + .return (rx570_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__scope_declarator:sym" :subid("136_1275511697.61926") :method +.sub "!PREFIX__scope_declarator:sym" :subid("139_1275600007.84296") :method .annotate 'line', 4 - $P560 = self."!PREFIX__!subrule"("scoped", "my") - new $P561, "ResizablePMCArray" - push $P561, $P560 - .return ($P561) + $P572 = self."!PREFIX__!subrule"("scoped", "my") + new $P573, "ResizablePMCArray" + push $P573, $P572 + .return ($P573) .end .namespace ["NQP";"Grammar"] -.sub "scope_declarator:sym" :subid("137_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "scope_declarator:sym" :subid("140_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx565_tgt - .local int rx565_pos - .local int rx565_off - .local int rx565_eos - .local int rx565_rep - .local pmc rx565_cur - (rx565_cur, rx565_pos, rx565_tgt) = self."!cursor_start"() - rx565_cur."!cursor_debug"("START ", "scope_declarator:sym") - .lex unicode:"$\x{a2}", rx565_cur + .local string rx577_tgt + .local int rx577_pos + .local int rx577_off + .local int rx577_eos + .local int rx577_rep + .local pmc rx577_cur + (rx577_cur, rx577_pos, rx577_tgt) = self."!cursor_start"() + rx577_cur."!cursor_debug"("START ", "scope_declarator:sym") + .lex unicode:"$\x{a2}", rx577_cur .local pmc match .lex "$/", match - length rx565_eos, rx565_tgt - gt rx565_pos, rx565_eos, rx565_done - set rx565_off, 0 - lt rx565_pos, 2, rx565_start - sub rx565_off, rx565_pos, 1 - substr rx565_tgt, rx565_tgt, rx565_off - rx565_start: + length rx577_eos, rx577_tgt + gt rx577_pos, rx577_eos, rx577_done + set rx577_off, 0 + lt rx577_pos, 2, rx577_start + sub rx577_off, rx577_pos, 1 + substr rx577_tgt, rx577_tgt, rx577_off + rx577_start: $I10 = self.'from'() - ne $I10, -1, rxscan569_done - goto rxscan569_scan - rxscan569_loop: - ($P10) = rx565_cur."from"() + ne $I10, -1, rxscan581_done + goto rxscan581_scan + rxscan581_loop: + ($P10) = rx577_cur."from"() inc $P10 - set rx565_pos, $P10 - ge rx565_pos, rx565_eos, rxscan569_done - rxscan569_scan: - set_addr $I10, rxscan569_loop - rx565_cur."!mark_push"(0, rx565_pos, $I10) - rxscan569_done: -.annotate 'line', 272 + set rx577_pos, $P10 + ge rx577_pos, rx577_eos, rxscan581_done + rxscan581_scan: + set_addr $I10, rxscan581_loop + rx577_cur."!mark_push"(0, rx577_pos, $I10) + rxscan581_done: +.annotate 'line', 274 # rx subcapture "sym" - set_addr $I10, rxcap_570_fail - rx565_cur."!mark_push"(0, rx565_pos, $I10) + set_addr $I10, rxcap_582_fail + rx577_cur."!mark_push"(0, rx577_pos, $I10) # rx literal "our" - add $I11, rx565_pos, 3 - gt $I11, rx565_eos, rx565_fail - sub $I11, rx565_pos, rx565_off - substr $S10, rx565_tgt, $I11, 3 - ne $S10, "our", rx565_fail - add rx565_pos, 3 - set_addr $I10, rxcap_570_fail - ($I12, $I11) = rx565_cur."!mark_peek"($I10) - rx565_cur."!cursor_pos"($I11) - ($P10) = rx565_cur."!cursor_start"() - $P10."!cursor_pass"(rx565_pos, "") - rx565_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx577_pos, 3 + gt $I11, rx577_eos, rx577_fail + sub $I11, rx577_pos, rx577_off + substr $S10, rx577_tgt, $I11, 3 + ne $S10, "our", rx577_fail + add rx577_pos, 3 + set_addr $I10, rxcap_582_fail + ($I12, $I11) = rx577_cur."!mark_peek"($I10) + rx577_cur."!cursor_pos"($I11) + ($P10) = rx577_cur."!cursor_start"() + $P10."!cursor_pass"(rx577_pos, "") + rx577_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_570_done - rxcap_570_fail: - goto rx565_fail - rxcap_570_done: + goto rxcap_582_done + rxcap_582_fail: + goto rx577_fail + rxcap_582_done: # rx subrule "scoped" subtype=capture negate= - rx565_cur."!cursor_pos"(rx565_pos) - $P10 = rx565_cur."scoped"("our") - unless $P10, rx565_fail - rx565_cur."!mark_push"(0, -1, 0, $P10) + rx577_cur."!cursor_pos"(rx577_pos) + $P10 = rx577_cur."scoped"("our") + unless $P10, rx577_fail + rx577_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("scoped") - rx565_pos = $P10."pos"() + rx577_pos = $P10."pos"() # rx pass - rx565_cur."!cursor_pass"(rx565_pos, "scope_declarator:sym") - rx565_cur."!cursor_debug"("PASS ", "scope_declarator:sym", " at pos=", rx565_pos) - .return (rx565_cur) - rx565_fail: -.annotate 'line', 4 - (rx565_rep, rx565_pos, $I10, $P10) = rx565_cur."!mark_fail"(0) - lt rx565_pos, -1, rx565_done - eq rx565_pos, -1, rx565_fail + rx577_cur."!cursor_pass"(rx577_pos, "scope_declarator:sym") + rx577_cur."!cursor_debug"("PASS ", "scope_declarator:sym", " at pos=", rx577_pos) + .return (rx577_cur) + rx577_fail: +.annotate 'line', 4 + (rx577_rep, rx577_pos, $I10, $P10) = rx577_cur."!mark_fail"(0) + lt rx577_pos, -1, rx577_done + eq rx577_pos, -1, rx577_fail jump $I10 - rx565_done: - rx565_cur."!cursor_fail"() - rx565_cur."!cursor_debug"("FAIL ", "scope_declarator:sym") - .return (rx565_cur) + rx577_done: + rx577_cur."!cursor_fail"() + rx577_cur."!cursor_debug"("FAIL ", "scope_declarator:sym") + .return (rx577_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__scope_declarator:sym" :subid("138_1275511697.61926") :method +.sub "!PREFIX__scope_declarator:sym" :subid("141_1275600007.84296") :method .annotate 'line', 4 - $P567 = self."!PREFIX__!subrule"("scoped", "our") - new $P568, "ResizablePMCArray" - push $P568, $P567 - .return ($P568) + $P579 = self."!PREFIX__!subrule"("scoped", "our") + new $P580, "ResizablePMCArray" + push $P580, $P579 + .return ($P580) .end .namespace ["NQP";"Grammar"] -.sub "scope_declarator:sym" :subid("139_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "scope_declarator:sym" :subid("142_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx572_tgt - .local int rx572_pos - .local int rx572_off - .local int rx572_eos - .local int rx572_rep - .local pmc rx572_cur - (rx572_cur, rx572_pos, rx572_tgt) = self."!cursor_start"() - rx572_cur."!cursor_debug"("START ", "scope_declarator:sym") - .lex unicode:"$\x{a2}", rx572_cur + .local string rx584_tgt + .local int rx584_pos + .local int rx584_off + .local int rx584_eos + .local int rx584_rep + .local pmc rx584_cur + (rx584_cur, rx584_pos, rx584_tgt) = self."!cursor_start"() + rx584_cur."!cursor_debug"("START ", "scope_declarator:sym") + .lex unicode:"$\x{a2}", rx584_cur .local pmc match .lex "$/", match - length rx572_eos, rx572_tgt - gt rx572_pos, rx572_eos, rx572_done - set rx572_off, 0 - lt rx572_pos, 2, rx572_start - sub rx572_off, rx572_pos, 1 - substr rx572_tgt, rx572_tgt, rx572_off - rx572_start: + length rx584_eos, rx584_tgt + gt rx584_pos, rx584_eos, rx584_done + set rx584_off, 0 + lt rx584_pos, 2, rx584_start + sub rx584_off, rx584_pos, 1 + substr rx584_tgt, rx584_tgt, rx584_off + rx584_start: $I10 = self.'from'() - ne $I10, -1, rxscan576_done - goto rxscan576_scan - rxscan576_loop: - ($P10) = rx572_cur."from"() + ne $I10, -1, rxscan588_done + goto rxscan588_scan + rxscan588_loop: + ($P10) = rx584_cur."from"() inc $P10 - set rx572_pos, $P10 - ge rx572_pos, rx572_eos, rxscan576_done - rxscan576_scan: - set_addr $I10, rxscan576_loop - rx572_cur."!mark_push"(0, rx572_pos, $I10) - rxscan576_done: -.annotate 'line', 273 + set rx584_pos, $P10 + ge rx584_pos, rx584_eos, rxscan588_done + rxscan588_scan: + set_addr $I10, rxscan588_loop + rx584_cur."!mark_push"(0, rx584_pos, $I10) + rxscan588_done: +.annotate 'line', 275 # rx subcapture "sym" - set_addr $I10, rxcap_577_fail - rx572_cur."!mark_push"(0, rx572_pos, $I10) + set_addr $I10, rxcap_589_fail + rx584_cur."!mark_push"(0, rx584_pos, $I10) # rx literal "has" - add $I11, rx572_pos, 3 - gt $I11, rx572_eos, rx572_fail - sub $I11, rx572_pos, rx572_off - substr $S10, rx572_tgt, $I11, 3 - ne $S10, "has", rx572_fail - add rx572_pos, 3 - set_addr $I10, rxcap_577_fail - ($I12, $I11) = rx572_cur."!mark_peek"($I10) - rx572_cur."!cursor_pos"($I11) - ($P10) = rx572_cur."!cursor_start"() - $P10."!cursor_pass"(rx572_pos, "") - rx572_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx584_pos, 3 + gt $I11, rx584_eos, rx584_fail + sub $I11, rx584_pos, rx584_off + substr $S10, rx584_tgt, $I11, 3 + ne $S10, "has", rx584_fail + add rx584_pos, 3 + set_addr $I10, rxcap_589_fail + ($I12, $I11) = rx584_cur."!mark_peek"($I10) + rx584_cur."!cursor_pos"($I11) + ($P10) = rx584_cur."!cursor_start"() + $P10."!cursor_pass"(rx584_pos, "") + rx584_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_577_done - rxcap_577_fail: - goto rx572_fail - rxcap_577_done: + goto rxcap_589_done + rxcap_589_fail: + goto rx584_fail + rxcap_589_done: # rx subrule "scoped" subtype=capture negate= - rx572_cur."!cursor_pos"(rx572_pos) - $P10 = rx572_cur."scoped"("has") - unless $P10, rx572_fail - rx572_cur."!mark_push"(0, -1, 0, $P10) + rx584_cur."!cursor_pos"(rx584_pos) + $P10 = rx584_cur."scoped"("has") + unless $P10, rx584_fail + rx584_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("scoped") - rx572_pos = $P10."pos"() + rx584_pos = $P10."pos"() # rx pass - rx572_cur."!cursor_pass"(rx572_pos, "scope_declarator:sym") - rx572_cur."!cursor_debug"("PASS ", "scope_declarator:sym", " at pos=", rx572_pos) - .return (rx572_cur) - rx572_fail: -.annotate 'line', 4 - (rx572_rep, rx572_pos, $I10, $P10) = rx572_cur."!mark_fail"(0) - lt rx572_pos, -1, rx572_done - eq rx572_pos, -1, rx572_fail + rx584_cur."!cursor_pass"(rx584_pos, "scope_declarator:sym") + rx584_cur."!cursor_debug"("PASS ", "scope_declarator:sym", " at pos=", rx584_pos) + .return (rx584_cur) + rx584_fail: +.annotate 'line', 4 + (rx584_rep, rx584_pos, $I10, $P10) = rx584_cur."!mark_fail"(0) + lt rx584_pos, -1, rx584_done + eq rx584_pos, -1, rx584_fail jump $I10 - rx572_done: - rx572_cur."!cursor_fail"() - rx572_cur."!cursor_debug"("FAIL ", "scope_declarator:sym") - .return (rx572_cur) + rx584_done: + rx584_cur."!cursor_fail"() + rx584_cur."!cursor_debug"("FAIL ", "scope_declarator:sym") + .return (rx584_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__scope_declarator:sym" :subid("140_1275511697.61926") :method +.sub "!PREFIX__scope_declarator:sym" :subid("143_1275600007.84296") :method .annotate 'line', 4 - $P574 = self."!PREFIX__!subrule"("scoped", "has") - new $P575, "ResizablePMCArray" - push $P575, $P574 - .return ($P575) + $P586 = self."!PREFIX__!subrule"("scoped", "has") + new $P587, "ResizablePMCArray" + push $P587, $P586 + .return ($P587) .end .namespace ["NQP";"Grammar"] -.sub "scoped" :subid("141_1275511697.61926") :method :outer("11_1275511697.61926") - .param pmc param_579 -.annotate 'line', 275 - .lex "$*SCOPE", param_579 -.annotate 'line', 4 - .local string rx580_tgt - .local int rx580_pos - .local int rx580_off - .local int rx580_eos - .local int rx580_rep - .local pmc rx580_cur - (rx580_cur, rx580_pos, rx580_tgt) = self."!cursor_start"() - rx580_cur."!cursor_debug"("START ", "scoped") - rx580_cur."!cursor_caparray"("typename") - .lex unicode:"$\x{a2}", rx580_cur +.sub "scoped" :subid("144_1275600007.84296") :method :outer("11_1275600007.84296") + .param pmc param_591 +.annotate 'line', 277 + .lex "$*SCOPE", param_591 +.annotate 'line', 4 + .local string rx592_tgt + .local int rx592_pos + .local int rx592_off + .local int rx592_eos + .local int rx592_rep + .local pmc rx592_cur + (rx592_cur, rx592_pos, rx592_tgt) = self."!cursor_start"() + rx592_cur."!cursor_debug"("START ", "scoped") + .lex unicode:"$\x{a2}", rx592_cur .local pmc match .lex "$/", match - length rx580_eos, rx580_tgt - gt rx580_pos, rx580_eos, rx580_done - set rx580_off, 0 - lt rx580_pos, 2, rx580_start - sub rx580_off, rx580_pos, 1 - substr rx580_tgt, rx580_tgt, rx580_off - rx580_start: + length rx592_eos, rx592_tgt + gt rx592_pos, rx592_eos, rx592_done + set rx592_off, 0 + lt rx592_pos, 2, rx592_start + sub rx592_off, rx592_pos, 1 + substr rx592_tgt, rx592_tgt, rx592_off + rx592_start: $I10 = self.'from'() - ne $I10, -1, rxscan583_done - goto rxscan583_scan - rxscan583_loop: - ($P10) = rx580_cur."from"() + ne $I10, -1, rxscan595_done + goto rxscan595_scan + rxscan595_loop: + ($P10) = rx592_cur."from"() inc $P10 - set rx580_pos, $P10 - ge rx580_pos, rx580_eos, rxscan583_done - rxscan583_scan: - set_addr $I10, rxscan583_loop - rx580_cur."!mark_push"(0, rx580_pos, $I10) - rxscan583_done: - alt584_0: -.annotate 'line', 275 - set_addr $I10, alt584_1 - rx580_cur."!mark_push"(0, rx580_pos, $I10) -.annotate 'line', 276 + set rx592_pos, $P10 + ge rx592_pos, rx592_eos, rxscan595_done + rxscan595_scan: + set_addr $I10, rxscan595_loop + rx592_cur."!mark_push"(0, rx592_pos, $I10) + rxscan595_done: + alt596_0: +.annotate 'line', 277 + set_addr $I10, alt596_1 + rx592_cur."!mark_push"(0, rx592_pos, $I10) +.annotate 'line', 278 # rx subrule "ws" subtype=method negate= - rx580_cur."!cursor_pos"(rx580_pos) - $P10 = rx580_cur."ws"() - unless $P10, rx580_fail - rx580_pos = $P10."pos"() + rx592_cur."!cursor_pos"(rx592_pos) + $P10 = rx592_cur."ws"() + unless $P10, rx592_fail + rx592_pos = $P10."pos"() # rx subrule "declarator" subtype=capture negate= - rx580_cur."!cursor_pos"(rx580_pos) - $P10 = rx580_cur."declarator"() - unless $P10, rx580_fail - rx580_cur."!mark_push"(0, -1, 0, $P10) + rx592_cur."!cursor_pos"(rx592_pos) + $P10 = rx592_cur."declarator"() + unless $P10, rx592_fail + rx592_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("declarator") - rx580_pos = $P10."pos"() - # rx subrule "ws" subtype=method negate= - rx580_cur."!cursor_pos"(rx580_pos) - $P10 = rx580_cur."ws"() - unless $P10, rx580_fail - rx580_pos = $P10."pos"() - goto alt584_end - alt584_1: -.annotate 'line', 277 + rx592_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx580_cur."!cursor_pos"(rx580_pos) - $P10 = rx580_cur."ws"() - unless $P10, rx580_fail - rx580_pos = $P10."pos"() - # rx rxquantr588 ** 1..* - set_addr $I589, rxquantr588_done - rx580_cur."!mark_push"(0, -1, $I589) - rxquantr588_loop: - # rx subrule "typename" subtype=capture negate= - rx580_cur."!cursor_pos"(rx580_pos) - $P10 = rx580_cur."typename"() - unless $P10, rx580_fail - rx580_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("typename") - rx580_pos = $P10."pos"() - (rx580_rep) = rx580_cur."!mark_commit"($I589) - rx580_cur."!mark_push"(rx580_rep, rx580_pos, $I589) - goto rxquantr588_loop - rxquantr588_done: + rx592_cur."!cursor_pos"(rx592_pos) + $P10 = rx592_cur."ws"() + unless $P10, rx592_fail + rx592_pos = $P10."pos"() + goto alt596_end + alt596_1: +.annotate 'line', 279 # rx subrule "ws" subtype=method negate= - rx580_cur."!cursor_pos"(rx580_pos) - $P10 = rx580_cur."ws"() - unless $P10, rx580_fail - rx580_pos = $P10."pos"() - # rx subrule "declarator" subtype=capture negate= - rx580_cur."!cursor_pos"(rx580_pos) - $P10 = rx580_cur."declarator"() - unless $P10, rx580_fail - rx580_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("declarator") - rx580_pos = $P10."pos"() + rx592_cur."!cursor_pos"(rx592_pos) + $P10 = rx592_cur."ws"() + unless $P10, rx592_fail + rx592_pos = $P10."pos"() + # rx subrule "multi_declarator" subtype=capture negate= + rx592_cur."!cursor_pos"(rx592_pos) + $P10 = rx592_cur."multi_declarator"() + unless $P10, rx592_fail + rx592_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("multi_declarator") + rx592_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx580_cur."!cursor_pos"(rx580_pos) - $P10 = rx580_cur."ws"() - unless $P10, rx580_fail - rx580_pos = $P10."pos"() - alt584_end: -.annotate 'line', 275 + rx592_cur."!cursor_pos"(rx592_pos) + $P10 = rx592_cur."ws"() + unless $P10, rx592_fail + rx592_pos = $P10."pos"() + alt596_end: +.annotate 'line', 277 # rx pass - rx580_cur."!cursor_pass"(rx580_pos, "scoped") - rx580_cur."!cursor_debug"("PASS ", "scoped", " at pos=", rx580_pos) - .return (rx580_cur) - rx580_fail: -.annotate 'line', 4 - (rx580_rep, rx580_pos, $I10, $P10) = rx580_cur."!mark_fail"(0) - lt rx580_pos, -1, rx580_done - eq rx580_pos, -1, rx580_fail + rx592_cur."!cursor_pass"(rx592_pos, "scoped") + rx592_cur."!cursor_debug"("PASS ", "scoped", " at pos=", rx592_pos) + .return (rx592_cur) + rx592_fail: +.annotate 'line', 4 + (rx592_rep, rx592_pos, $I10, $P10) = rx592_cur."!mark_fail"(0) + lt rx592_pos, -1, rx592_done + eq rx592_pos, -1, rx592_fail jump $I10 - rx580_done: - rx580_cur."!cursor_fail"() - rx580_cur."!cursor_debug"("FAIL ", "scoped") - .return (rx580_cur) + rx592_done: + rx592_cur."!cursor_fail"() + rx592_cur."!cursor_debug"("FAIL ", "scoped") + .return (rx592_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__scoped" :subid("142_1275511697.61926") :method +.sub "!PREFIX__scoped" :subid("145_1275600007.84296") :method .annotate 'line', 4 - new $P582, "ResizablePMCArray" - push $P582, "" - push $P582, "" - .return ($P582) + new $P594, "ResizablePMCArray" + push $P594, "" + push $P594, "" + .return ($P594) .end .namespace ["NQP";"Grammar"] -.sub "typename" :subid("143_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "typename" :subid("146_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx593_tgt - .local int rx593_pos - .local int rx593_off - .local int rx593_eos - .local int rx593_rep - .local pmc rx593_cur - (rx593_cur, rx593_pos, rx593_tgt) = self."!cursor_start"() - rx593_cur."!cursor_debug"("START ", "typename") - .lex unicode:"$\x{a2}", rx593_cur + .local string rx602_tgt + .local int rx602_pos + .local int rx602_off + .local int rx602_eos + .local int rx602_rep + .local pmc rx602_cur + (rx602_cur, rx602_pos, rx602_tgt) = self."!cursor_start"() + rx602_cur."!cursor_debug"("START ", "typename") + .lex unicode:"$\x{a2}", rx602_cur .local pmc match .lex "$/", match - length rx593_eos, rx593_tgt - gt rx593_pos, rx593_eos, rx593_done - set rx593_off, 0 - lt rx593_pos, 2, rx593_start - sub rx593_off, rx593_pos, 1 - substr rx593_tgt, rx593_tgt, rx593_off - rx593_start: + length rx602_eos, rx602_tgt + gt rx602_pos, rx602_eos, rx602_done + set rx602_off, 0 + lt rx602_pos, 2, rx602_start + sub rx602_off, rx602_pos, 1 + substr rx602_tgt, rx602_tgt, rx602_off + rx602_start: $I10 = self.'from'() - ne $I10, -1, rxscan597_done - goto rxscan597_scan - rxscan597_loop: - ($P10) = rx593_cur."from"() + ne $I10, -1, rxscan606_done + goto rxscan606_scan + rxscan606_loop: + ($P10) = rx602_cur."from"() inc $P10 - set rx593_pos, $P10 - ge rx593_pos, rx593_eos, rxscan597_done - rxscan597_scan: - set_addr $I10, rxscan597_loop - rx593_cur."!mark_push"(0, rx593_pos, $I10) - rxscan597_done: -.annotate 'line', 280 + set rx602_pos, $P10 + ge rx602_pos, rx602_eos, rxscan606_done + rxscan606_scan: + set_addr $I10, rxscan606_loop + rx602_cur."!mark_push"(0, rx602_pos, $I10) + rxscan606_done: +.annotate 'line', 282 # rx subrule "name" subtype=capture negate= - rx593_cur."!cursor_pos"(rx593_pos) - $P10 = rx593_cur."name"() - unless $P10, rx593_fail - rx593_cur."!mark_push"(0, -1, 0, $P10) + rx602_cur."!cursor_pos"(rx602_pos) + $P10 = rx602_cur."name"() + unless $P10, rx602_fail + rx602_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("name") - rx593_pos = $P10."pos"() + rx602_pos = $P10."pos"() # rx pass - rx593_cur."!cursor_pass"(rx593_pos, "typename") - rx593_cur."!cursor_debug"("PASS ", "typename", " at pos=", rx593_pos) - .return (rx593_cur) - rx593_fail: -.annotate 'line', 4 - (rx593_rep, rx593_pos, $I10, $P10) = rx593_cur."!mark_fail"(0) - lt rx593_pos, -1, rx593_done - eq rx593_pos, -1, rx593_fail + rx602_cur."!cursor_pass"(rx602_pos, "typename") + rx602_cur."!cursor_debug"("PASS ", "typename", " at pos=", rx602_pos) + .return (rx602_cur) + rx602_fail: +.annotate 'line', 4 + (rx602_rep, rx602_pos, $I10, $P10) = rx602_cur."!mark_fail"(0) + lt rx602_pos, -1, rx602_done + eq rx602_pos, -1, rx602_fail jump $I10 - rx593_done: - rx593_cur."!cursor_fail"() - rx593_cur."!cursor_debug"("FAIL ", "typename") - .return (rx593_cur) + rx602_done: + rx602_cur."!cursor_fail"() + rx602_cur."!cursor_debug"("FAIL ", "typename") + .return (rx602_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__typename" :subid("144_1275511697.61926") :method +.sub "!PREFIX__typename" :subid("147_1275600007.84296") :method .annotate 'line', 4 - $P595 = self."!PREFIX__!subrule"("name", "") - new $P596, "ResizablePMCArray" - push $P596, $P595 - .return ($P596) + $P604 = self."!PREFIX__!subrule"("name", "") + new $P605, "ResizablePMCArray" + push $P605, $P604 + .return ($P605) .end .namespace ["NQP";"Grammar"] -.sub "declarator" :subid("145_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "declarator" :subid("148_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx599_tgt - .local int rx599_pos - .local int rx599_off - .local int rx599_eos - .local int rx599_rep - .local pmc rx599_cur - (rx599_cur, rx599_pos, rx599_tgt) = self."!cursor_start"() - rx599_cur."!cursor_debug"("START ", "declarator") - .lex unicode:"$\x{a2}", rx599_cur + .local string rx608_tgt + .local int rx608_pos + .local int rx608_off + .local int rx608_eos + .local int rx608_rep + .local pmc rx608_cur + (rx608_cur, rx608_pos, rx608_tgt) = self."!cursor_start"() + rx608_cur."!cursor_debug"("START ", "declarator") + .lex unicode:"$\x{a2}", rx608_cur .local pmc match .lex "$/", match - length rx599_eos, rx599_tgt - gt rx599_pos, rx599_eos, rx599_done - set rx599_off, 0 - lt rx599_pos, 2, rx599_start - sub rx599_off, rx599_pos, 1 - substr rx599_tgt, rx599_tgt, rx599_off - rx599_start: + length rx608_eos, rx608_tgt + gt rx608_pos, rx608_eos, rx608_done + set rx608_off, 0 + lt rx608_pos, 2, rx608_start + sub rx608_off, rx608_pos, 1 + substr rx608_tgt, rx608_tgt, rx608_off + rx608_start: $I10 = self.'from'() - ne $I10, -1, rxscan604_done - goto rxscan604_scan - rxscan604_loop: - ($P10) = rx599_cur."from"() + ne $I10, -1, rxscan613_done + goto rxscan613_scan + rxscan613_loop: + ($P10) = rx608_cur."from"() inc $P10 - set rx599_pos, $P10 - ge rx599_pos, rx599_eos, rxscan604_done - rxscan604_scan: - set_addr $I10, rxscan604_loop - rx599_cur."!mark_push"(0, rx599_pos, $I10) - rxscan604_done: - alt605_0: -.annotate 'line', 282 - set_addr $I10, alt605_1 - rx599_cur."!mark_push"(0, rx599_pos, $I10) -.annotate 'line', 283 + set rx608_pos, $P10 + ge rx608_pos, rx608_eos, rxscan613_done + rxscan613_scan: + set_addr $I10, rxscan613_loop + rx608_cur."!mark_push"(0, rx608_pos, $I10) + rxscan613_done: + alt614_0: +.annotate 'line', 284 + set_addr $I10, alt614_1 + rx608_cur."!mark_push"(0, rx608_pos, $I10) +.annotate 'line', 285 # rx subrule "variable_declarator" subtype=capture negate= - rx599_cur."!cursor_pos"(rx599_pos) - $P10 = rx599_cur."variable_declarator"() - unless $P10, rx599_fail - rx599_cur."!mark_push"(0, -1, 0, $P10) + rx608_cur."!cursor_pos"(rx608_pos) + $P10 = rx608_cur."variable_declarator"() + unless $P10, rx608_fail + rx608_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("variable_declarator") - rx599_pos = $P10."pos"() - goto alt605_end - alt605_1: -.annotate 'line', 284 + rx608_pos = $P10."pos"() + goto alt614_end + alt614_1: +.annotate 'line', 286 # rx subrule "routine_declarator" subtype=capture negate= - rx599_cur."!cursor_pos"(rx599_pos) - $P10 = rx599_cur."routine_declarator"() - unless $P10, rx599_fail - rx599_cur."!mark_push"(0, -1, 0, $P10) + rx608_cur."!cursor_pos"(rx608_pos) + $P10 = rx608_cur."routine_declarator"() + unless $P10, rx608_fail + rx608_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("routine_declarator") - rx599_pos = $P10."pos"() - alt605_end: -.annotate 'line', 282 + rx608_pos = $P10."pos"() + alt614_end: +.annotate 'line', 284 # rx pass - rx599_cur."!cursor_pass"(rx599_pos, "declarator") - rx599_cur."!cursor_debug"("PASS ", "declarator", " at pos=", rx599_pos) - .return (rx599_cur) - rx599_fail: -.annotate 'line', 4 - (rx599_rep, rx599_pos, $I10, $P10) = rx599_cur."!mark_fail"(0) - lt rx599_pos, -1, rx599_done - eq rx599_pos, -1, rx599_fail + rx608_cur."!cursor_pass"(rx608_pos, "declarator") + rx608_cur."!cursor_debug"("PASS ", "declarator", " at pos=", rx608_pos) + .return (rx608_cur) + rx608_fail: +.annotate 'line', 4 + (rx608_rep, rx608_pos, $I10, $P10) = rx608_cur."!mark_fail"(0) + lt rx608_pos, -1, rx608_done + eq rx608_pos, -1, rx608_fail jump $I10 - rx599_done: - rx599_cur."!cursor_fail"() - rx599_cur."!cursor_debug"("FAIL ", "declarator") - .return (rx599_cur) + rx608_done: + rx608_cur."!cursor_fail"() + rx608_cur."!cursor_debug"("FAIL ", "declarator") + .return (rx608_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__declarator" :subid("146_1275511697.61926") :method +.sub "!PREFIX__declarator" :subid("149_1275600007.84296") :method .annotate 'line', 4 - $P601 = self."!PREFIX__!subrule"("routine_declarator", "") - $P602 = self."!PREFIX__!subrule"("variable_declarator", "") - new $P603, "ResizablePMCArray" - push $P603, $P601 - push $P603, $P602 - .return ($P603) + $P610 = self."!PREFIX__!subrule"("routine_declarator", "") + $P611 = self."!PREFIX__!subrule"("variable_declarator", "") + new $P612, "ResizablePMCArray" + push $P612, $P610 + push $P612, $P611 + .return ($P612) .end .namespace ["NQP";"Grammar"] -.sub "variable_declarator" :subid("147_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "variable_declarator" :subid("150_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx607_tgt - .local int rx607_pos - .local int rx607_off - .local int rx607_eos - .local int rx607_rep - .local pmc rx607_cur - (rx607_cur, rx607_pos, rx607_tgt) = self."!cursor_start"() - rx607_cur."!cursor_debug"("START ", "variable_declarator") - .lex unicode:"$\x{a2}", rx607_cur + .local string rx616_tgt + .local int rx616_pos + .local int rx616_off + .local int rx616_eos + .local int rx616_rep + .local pmc rx616_cur + (rx616_cur, rx616_pos, rx616_tgt) = self."!cursor_start"() + rx616_cur."!cursor_debug"("START ", "variable_declarator") + .lex unicode:"$\x{a2}", rx616_cur .local pmc match .lex "$/", match - length rx607_eos, rx607_tgt - gt rx607_pos, rx607_eos, rx607_done - set rx607_off, 0 - lt rx607_pos, 2, rx607_start - sub rx607_off, rx607_pos, 1 - substr rx607_tgt, rx607_tgt, rx607_off - rx607_start: + length rx616_eos, rx616_tgt + gt rx616_pos, rx616_eos, rx616_done + set rx616_off, 0 + lt rx616_pos, 2, rx616_start + sub rx616_off, rx616_pos, 1 + substr rx616_tgt, rx616_tgt, rx616_off + rx616_start: $I10 = self.'from'() - ne $I10, -1, rxscan611_done - goto rxscan611_scan - rxscan611_loop: - ($P10) = rx607_cur."from"() + ne $I10, -1, rxscan620_done + goto rxscan620_scan + rxscan620_loop: + ($P10) = rx616_cur."from"() inc $P10 - set rx607_pos, $P10 - ge rx607_pos, rx607_eos, rxscan611_done - rxscan611_scan: - set_addr $I10, rxscan611_loop - rx607_cur."!mark_push"(0, rx607_pos, $I10) - rxscan611_done: -.annotate 'line', 287 + set rx616_pos, $P10 + ge rx616_pos, rx616_eos, rxscan620_done + rxscan620_scan: + set_addr $I10, rxscan620_loop + rx616_cur."!mark_push"(0, rx616_pos, $I10) + rxscan620_done: +.annotate 'line', 289 # rx subrule "variable" subtype=capture negate= - rx607_cur."!cursor_pos"(rx607_pos) - $P10 = rx607_cur."variable"() - unless $P10, rx607_fail - rx607_cur."!mark_push"(0, -1, 0, $P10) + rx616_cur."!cursor_pos"(rx616_pos) + $P10 = rx616_cur."variable"() + unless $P10, rx616_fail + rx616_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("variable") - rx607_pos = $P10."pos"() + rx616_pos = $P10."pos"() # rx pass - rx607_cur."!cursor_pass"(rx607_pos, "variable_declarator") - rx607_cur."!cursor_debug"("PASS ", "variable_declarator", " at pos=", rx607_pos) - .return (rx607_cur) - rx607_fail: -.annotate 'line', 4 - (rx607_rep, rx607_pos, $I10, $P10) = rx607_cur."!mark_fail"(0) - lt rx607_pos, -1, rx607_done - eq rx607_pos, -1, rx607_fail + rx616_cur."!cursor_pass"(rx616_pos, "variable_declarator") + rx616_cur."!cursor_debug"("PASS ", "variable_declarator", " at pos=", rx616_pos) + .return (rx616_cur) + rx616_fail: +.annotate 'line', 4 + (rx616_rep, rx616_pos, $I10, $P10) = rx616_cur."!mark_fail"(0) + lt rx616_pos, -1, rx616_done + eq rx616_pos, -1, rx616_fail jump $I10 - rx607_done: - rx607_cur."!cursor_fail"() - rx607_cur."!cursor_debug"("FAIL ", "variable_declarator") - .return (rx607_cur) + rx616_done: + rx616_cur."!cursor_fail"() + rx616_cur."!cursor_debug"("FAIL ", "variable_declarator") + .return (rx616_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__variable_declarator" :subid("148_1275511697.61926") :method +.sub "!PREFIX__variable_declarator" :subid("151_1275600007.84296") :method .annotate 'line', 4 - $P609 = self."!PREFIX__!subrule"("variable", "") - new $P610, "ResizablePMCArray" - push $P610, $P609 - .return ($P610) + $P618 = self."!PREFIX__!subrule"("variable", "") + new $P619, "ResizablePMCArray" + push $P619, $P618 + .return ($P619) .end .namespace ["NQP";"Grammar"] -.sub "routine_declarator" :subid("149_1275511697.61926") :method -.annotate 'line', 289 - $P613 = self."!protoregex"("routine_declarator") - .return ($P613) +.sub "routine_declarator" :subid("152_1275600007.84296") :method +.annotate 'line', 291 + $P622 = self."!protoregex"("routine_declarator") + .return ($P622) .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__routine_declarator" :subid("150_1275511697.61926") :method -.annotate 'line', 289 - $P615 = self."!PREFIX__!protoregex"("routine_declarator") - .return ($P615) +.sub "!PREFIX__routine_declarator" :subid("153_1275600007.84296") :method +.annotate 'line', 291 + $P624 = self."!PREFIX__!protoregex"("routine_declarator") + .return ($P624) .end .namespace ["NQP";"Grammar"] -.sub "routine_declarator:sym" :subid("151_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "routine_declarator:sym" :subid("154_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx617_tgt - .local int rx617_pos - .local int rx617_off - .local int rx617_eos - .local int rx617_rep - .local pmc rx617_cur - (rx617_cur, rx617_pos, rx617_tgt) = self."!cursor_start"() - rx617_cur."!cursor_debug"("START ", "routine_declarator:sym") - .lex unicode:"$\x{a2}", rx617_cur + .local string rx626_tgt + .local int rx626_pos + .local int rx626_off + .local int rx626_eos + .local int rx626_rep + .local pmc rx626_cur + (rx626_cur, rx626_pos, rx626_tgt) = self."!cursor_start"() + rx626_cur."!cursor_debug"("START ", "routine_declarator:sym") + .lex unicode:"$\x{a2}", rx626_cur .local pmc match .lex "$/", match - length rx617_eos, rx617_tgt - gt rx617_pos, rx617_eos, rx617_done - set rx617_off, 0 - lt rx617_pos, 2, rx617_start - sub rx617_off, rx617_pos, 1 - substr rx617_tgt, rx617_tgt, rx617_off - rx617_start: + length rx626_eos, rx626_tgt + gt rx626_pos, rx626_eos, rx626_done + set rx626_off, 0 + lt rx626_pos, 2, rx626_start + sub rx626_off, rx626_pos, 1 + substr rx626_tgt, rx626_tgt, rx626_off + rx626_start: $I10 = self.'from'() - ne $I10, -1, rxscan621_done - goto rxscan621_scan - rxscan621_loop: - ($P10) = rx617_cur."from"() + ne $I10, -1, rxscan630_done + goto rxscan630_scan + rxscan630_loop: + ($P10) = rx626_cur."from"() inc $P10 - set rx617_pos, $P10 - ge rx617_pos, rx617_eos, rxscan621_done - rxscan621_scan: - set_addr $I10, rxscan621_loop - rx617_cur."!mark_push"(0, rx617_pos, $I10) - rxscan621_done: -.annotate 'line', 290 + set rx626_pos, $P10 + ge rx626_pos, rx626_eos, rxscan630_done + rxscan630_scan: + set_addr $I10, rxscan630_loop + rx626_cur."!mark_push"(0, rx626_pos, $I10) + rxscan630_done: +.annotate 'line', 292 # rx subcapture "sym" - set_addr $I10, rxcap_622_fail - rx617_cur."!mark_push"(0, rx617_pos, $I10) + set_addr $I10, rxcap_631_fail + rx626_cur."!mark_push"(0, rx626_pos, $I10) # rx literal "sub" - add $I11, rx617_pos, 3 - gt $I11, rx617_eos, rx617_fail - sub $I11, rx617_pos, rx617_off - substr $S10, rx617_tgt, $I11, 3 - ne $S10, "sub", rx617_fail - add rx617_pos, 3 - set_addr $I10, rxcap_622_fail - ($I12, $I11) = rx617_cur."!mark_peek"($I10) - rx617_cur."!cursor_pos"($I11) - ($P10) = rx617_cur."!cursor_start"() - $P10."!cursor_pass"(rx617_pos, "") - rx617_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx626_pos, 3 + gt $I11, rx626_eos, rx626_fail + sub $I11, rx626_pos, rx626_off + substr $S10, rx626_tgt, $I11, 3 + ne $S10, "sub", rx626_fail + add rx626_pos, 3 + set_addr $I10, rxcap_631_fail + ($I12, $I11) = rx626_cur."!mark_peek"($I10) + rx626_cur."!cursor_pos"($I11) + ($P10) = rx626_cur."!cursor_start"() + $P10."!cursor_pass"(rx626_pos, "") + rx626_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_622_done - rxcap_622_fail: - goto rx617_fail - rxcap_622_done: + goto rxcap_631_done + rxcap_631_fail: + goto rx626_fail + rxcap_631_done: # rx subrule "routine_def" subtype=capture negate= - rx617_cur."!cursor_pos"(rx617_pos) - $P10 = rx617_cur."routine_def"() - unless $P10, rx617_fail - rx617_cur."!mark_push"(0, -1, 0, $P10) + rx626_cur."!cursor_pos"(rx626_pos) + $P10 = rx626_cur."routine_def"() + unless $P10, rx626_fail + rx626_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("routine_def") - rx617_pos = $P10."pos"() + rx626_pos = $P10."pos"() # rx pass - rx617_cur."!cursor_pass"(rx617_pos, "routine_declarator:sym") - rx617_cur."!cursor_debug"("PASS ", "routine_declarator:sym", " at pos=", rx617_pos) - .return (rx617_cur) - rx617_fail: -.annotate 'line', 4 - (rx617_rep, rx617_pos, $I10, $P10) = rx617_cur."!mark_fail"(0) - lt rx617_pos, -1, rx617_done - eq rx617_pos, -1, rx617_fail + rx626_cur."!cursor_pass"(rx626_pos, "routine_declarator:sym") + rx626_cur."!cursor_debug"("PASS ", "routine_declarator:sym", " at pos=", rx626_pos) + .return (rx626_cur) + rx626_fail: +.annotate 'line', 4 + (rx626_rep, rx626_pos, $I10, $P10) = rx626_cur."!mark_fail"(0) + lt rx626_pos, -1, rx626_done + eq rx626_pos, -1, rx626_fail jump $I10 - rx617_done: - rx617_cur."!cursor_fail"() - rx617_cur."!cursor_debug"("FAIL ", "routine_declarator:sym") - .return (rx617_cur) + rx626_done: + rx626_cur."!cursor_fail"() + rx626_cur."!cursor_debug"("FAIL ", "routine_declarator:sym") + .return (rx626_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__routine_declarator:sym" :subid("152_1275511697.61926") :method +.sub "!PREFIX__routine_declarator:sym" :subid("155_1275600007.84296") :method .annotate 'line', 4 - $P619 = self."!PREFIX__!subrule"("routine_def", "sub") - new $P620, "ResizablePMCArray" - push $P620, $P619 - .return ($P620) + $P628 = self."!PREFIX__!subrule"("routine_def", "sub") + new $P629, "ResizablePMCArray" + push $P629, $P628 + .return ($P629) .end .namespace ["NQP";"Grammar"] -.sub "routine_declarator:sym" :subid("153_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "routine_declarator:sym" :subid("156_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx624_tgt - .local int rx624_pos - .local int rx624_off - .local int rx624_eos - .local int rx624_rep - .local pmc rx624_cur - (rx624_cur, rx624_pos, rx624_tgt) = self."!cursor_start"() - rx624_cur."!cursor_debug"("START ", "routine_declarator:sym") - .lex unicode:"$\x{a2}", rx624_cur + .local string rx633_tgt + .local int rx633_pos + .local int rx633_off + .local int rx633_eos + .local int rx633_rep + .local pmc rx633_cur + (rx633_cur, rx633_pos, rx633_tgt) = self."!cursor_start"() + rx633_cur."!cursor_debug"("START ", "routine_declarator:sym") + .lex unicode:"$\x{a2}", rx633_cur .local pmc match .lex "$/", match - length rx624_eos, rx624_tgt - gt rx624_pos, rx624_eos, rx624_done - set rx624_off, 0 - lt rx624_pos, 2, rx624_start - sub rx624_off, rx624_pos, 1 - substr rx624_tgt, rx624_tgt, rx624_off - rx624_start: + length rx633_eos, rx633_tgt + gt rx633_pos, rx633_eos, rx633_done + set rx633_off, 0 + lt rx633_pos, 2, rx633_start + sub rx633_off, rx633_pos, 1 + substr rx633_tgt, rx633_tgt, rx633_off + rx633_start: $I10 = self.'from'() - ne $I10, -1, rxscan628_done - goto rxscan628_scan - rxscan628_loop: - ($P10) = rx624_cur."from"() + ne $I10, -1, rxscan637_done + goto rxscan637_scan + rxscan637_loop: + ($P10) = rx633_cur."from"() inc $P10 - set rx624_pos, $P10 - ge rx624_pos, rx624_eos, rxscan628_done - rxscan628_scan: - set_addr $I10, rxscan628_loop - rx624_cur."!mark_push"(0, rx624_pos, $I10) - rxscan628_done: -.annotate 'line', 291 + set rx633_pos, $P10 + ge rx633_pos, rx633_eos, rxscan637_done + rxscan637_scan: + set_addr $I10, rxscan637_loop + rx633_cur."!mark_push"(0, rx633_pos, $I10) + rxscan637_done: +.annotate 'line', 293 # rx subcapture "sym" - set_addr $I10, rxcap_629_fail - rx624_cur."!mark_push"(0, rx624_pos, $I10) + set_addr $I10, rxcap_638_fail + rx633_cur."!mark_push"(0, rx633_pos, $I10) # rx literal "method" - add $I11, rx624_pos, 6 - gt $I11, rx624_eos, rx624_fail - sub $I11, rx624_pos, rx624_off - substr $S10, rx624_tgt, $I11, 6 - ne $S10, "method", rx624_fail - add rx624_pos, 6 - set_addr $I10, rxcap_629_fail - ($I12, $I11) = rx624_cur."!mark_peek"($I10) - rx624_cur."!cursor_pos"($I11) - ($P10) = rx624_cur."!cursor_start"() - $P10."!cursor_pass"(rx624_pos, "") - rx624_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx633_pos, 6 + gt $I11, rx633_eos, rx633_fail + sub $I11, rx633_pos, rx633_off + substr $S10, rx633_tgt, $I11, 6 + ne $S10, "method", rx633_fail + add rx633_pos, 6 + set_addr $I10, rxcap_638_fail + ($I12, $I11) = rx633_cur."!mark_peek"($I10) + rx633_cur."!cursor_pos"($I11) + ($P10) = rx633_cur."!cursor_start"() + $P10."!cursor_pass"(rx633_pos, "") + rx633_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_629_done - rxcap_629_fail: - goto rx624_fail - rxcap_629_done: + goto rxcap_638_done + rxcap_638_fail: + goto rx633_fail + rxcap_638_done: # rx subrule "method_def" subtype=capture negate= - rx624_cur."!cursor_pos"(rx624_pos) - $P10 = rx624_cur."method_def"() - unless $P10, rx624_fail - rx624_cur."!mark_push"(0, -1, 0, $P10) + rx633_cur."!cursor_pos"(rx633_pos) + $P10 = rx633_cur."method_def"() + unless $P10, rx633_fail + rx633_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("method_def") - rx624_pos = $P10."pos"() + rx633_pos = $P10."pos"() # rx pass - rx624_cur."!cursor_pass"(rx624_pos, "routine_declarator:sym") - rx624_cur."!cursor_debug"("PASS ", "routine_declarator:sym", " at pos=", rx624_pos) - .return (rx624_cur) - rx624_fail: -.annotate 'line', 4 - (rx624_rep, rx624_pos, $I10, $P10) = rx624_cur."!mark_fail"(0) - lt rx624_pos, -1, rx624_done - eq rx624_pos, -1, rx624_fail + rx633_cur."!cursor_pass"(rx633_pos, "routine_declarator:sym") + rx633_cur."!cursor_debug"("PASS ", "routine_declarator:sym", " at pos=", rx633_pos) + .return (rx633_cur) + rx633_fail: +.annotate 'line', 4 + (rx633_rep, rx633_pos, $I10, $P10) = rx633_cur."!mark_fail"(0) + lt rx633_pos, -1, rx633_done + eq rx633_pos, -1, rx633_fail jump $I10 - rx624_done: - rx624_cur."!cursor_fail"() - rx624_cur."!cursor_debug"("FAIL ", "routine_declarator:sym") - .return (rx624_cur) + rx633_done: + rx633_cur."!cursor_fail"() + rx633_cur."!cursor_debug"("FAIL ", "routine_declarator:sym") + .return (rx633_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__routine_declarator:sym" :subid("154_1275511697.61926") :method +.sub "!PREFIX__routine_declarator:sym" :subid("157_1275600007.84296") :method .annotate 'line', 4 - $P626 = self."!PREFIX__!subrule"("method_def", "method") - new $P627, "ResizablePMCArray" - push $P627, $P626 - .return ($P627) + $P635 = self."!PREFIX__!subrule"("method_def", "method") + new $P636, "ResizablePMCArray" + push $P636, $P635 + .return ($P636) .end .namespace ["NQP";"Grammar"] -.sub "routine_def" :subid("155_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "routine_def" :subid("158_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx631_tgt - .local int rx631_pos - .local int rx631_off - .local int rx631_eos - .local int rx631_rep - .local pmc rx631_cur - (rx631_cur, rx631_pos, rx631_tgt) = self."!cursor_start"() - rx631_cur."!cursor_debug"("START ", "routine_def") - rx631_cur."!cursor_caparray"("sigil", "deflongname") - .lex unicode:"$\x{a2}", rx631_cur + .local string rx640_tgt + .local int rx640_pos + .local int rx640_off + .local int rx640_eos + .local int rx640_rep + .local pmc rx640_cur + (rx640_cur, rx640_pos, rx640_tgt) = self."!cursor_start"() + rx640_cur."!cursor_debug"("START ", "routine_def") + rx640_cur."!cursor_caparray"("deflongname", "sigil") + .lex unicode:"$\x{a2}", rx640_cur .local pmc match .lex "$/", match - length rx631_eos, rx631_tgt - gt rx631_pos, rx631_eos, rx631_done - set rx631_off, 0 - lt rx631_pos, 2, rx631_start - sub rx631_off, rx631_pos, 1 - substr rx631_tgt, rx631_tgt, rx631_off - rx631_start: + length rx640_eos, rx640_tgt + gt rx640_pos, rx640_eos, rx640_done + set rx640_off, 0 + lt rx640_pos, 2, rx640_start + sub rx640_off, rx640_pos, 1 + substr rx640_tgt, rx640_tgt, rx640_off + rx640_start: $I10 = self.'from'() - ne $I10, -1, rxscan634_done - goto rxscan634_scan - rxscan634_loop: - ($P10) = rx631_cur."from"() + ne $I10, -1, rxscan643_done + goto rxscan643_scan + rxscan643_loop: + ($P10) = rx640_cur."from"() inc $P10 - set rx631_pos, $P10 - ge rx631_pos, rx631_eos, rxscan634_done - rxscan634_scan: - set_addr $I10, rxscan634_loop - rx631_cur."!mark_push"(0, rx631_pos, $I10) - rxscan634_done: -.annotate 'line', 293 + set rx640_pos, $P10 + ge rx640_pos, rx640_eos, rxscan643_done + rxscan643_scan: + set_addr $I10, rxscan643_loop + rx640_cur."!mark_push"(0, rx640_pos, $I10) + rxscan643_done: +.annotate 'line', 295 # rx subrule "ws" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."ws"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() -.annotate 'line', 294 - # rx rxquantr636 ** 0..1 - set_addr $I642, rxquantr636_done - rx631_cur."!mark_push"(0, rx631_pos, $I642) - rxquantr636_loop: + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."ws"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() +.annotate 'line', 296 + # rx rxquantr645 ** 0..1 + set_addr $I651, rxquantr645_done + rx640_cur."!mark_push"(0, rx640_pos, $I651) + rxquantr645_loop: # rx subrule "ws" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."ws"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."ws"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() # rx subcapture "sigil" - set_addr $I10, rxcap_640_fail - rx631_cur."!mark_push"(0, rx631_pos, $I10) - # rx rxquantr638 ** 0..1 - set_addr $I639, rxquantr638_done - rx631_cur."!mark_push"(0, rx631_pos, $I639) - rxquantr638_loop: + set_addr $I10, rxcap_649_fail + rx640_cur."!mark_push"(0, rx640_pos, $I10) + # rx rxquantr647 ** 0..1 + set_addr $I648, rxquantr647_done + rx640_cur."!mark_push"(0, rx640_pos, $I648) + rxquantr647_loop: # rx literal "&" - add $I11, rx631_pos, 1 - gt $I11, rx631_eos, rx631_fail - sub $I11, rx631_pos, rx631_off - substr $S10, rx631_tgt, $I11, 1 - ne $S10, "&", rx631_fail - add rx631_pos, 1 - (rx631_rep) = rx631_cur."!mark_commit"($I639) - rxquantr638_done: - set_addr $I10, rxcap_640_fail - ($I12, $I11) = rx631_cur."!mark_peek"($I10) - rx631_cur."!cursor_pos"($I11) - ($P10) = rx631_cur."!cursor_start"() - $P10."!cursor_pass"(rx631_pos, "") - rx631_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx640_pos, 1 + gt $I11, rx640_eos, rx640_fail + sub $I11, rx640_pos, rx640_off + substr $S10, rx640_tgt, $I11, 1 + ne $S10, "&", rx640_fail + add rx640_pos, 1 + (rx640_rep) = rx640_cur."!mark_commit"($I648) + rxquantr647_done: + set_addr $I10, rxcap_649_fail + ($I12, $I11) = rx640_cur."!mark_peek"($I10) + rx640_cur."!cursor_pos"($I11) + ($P10) = rx640_cur."!cursor_start"() + $P10."!cursor_pass"(rx640_pos, "") + rx640_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sigil") - goto rxcap_640_done - rxcap_640_fail: - goto rx631_fail - rxcap_640_done: + goto rxcap_649_done + rxcap_649_fail: + goto rx640_fail + rxcap_649_done: # rx subrule "deflongname" subtype=capture negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."deflongname"() - unless $P10, rx631_fail - rx631_cur."!mark_push"(0, -1, 0, $P10) + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."deflongname"() + unless $P10, rx640_fail + rx640_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("deflongname") - rx631_pos = $P10."pos"() + rx640_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."ws"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() - (rx631_rep) = rx631_cur."!mark_commit"($I642) - rxquantr636_done: + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."ws"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() + (rx640_rep) = rx640_cur."!mark_commit"($I651) + rxquantr645_done: # rx subrule "ws" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."ws"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() -.annotate 'line', 295 + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."ws"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() +.annotate 'line', 297 # rx subrule "newpad" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."newpad"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."newpad"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."ws"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() - alt645_0: -.annotate 'line', 296 - set_addr $I10, alt645_1 - rx631_cur."!mark_push"(0, rx631_pos, $I10) + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."ws"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() + alt654_0: +.annotate 'line', 298 + set_addr $I10, alt654_1 + rx640_cur."!mark_push"(0, rx640_pos, $I10) # rx subrule "ws" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."ws"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."ws"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() # rx literal "(" - add $I11, rx631_pos, 1 - gt $I11, rx631_eos, rx631_fail - sub $I11, rx631_pos, rx631_off - substr $S10, rx631_tgt, $I11, 1 - ne $S10, "(", rx631_fail - add rx631_pos, 1 + add $I11, rx640_pos, 1 + gt $I11, rx640_eos, rx640_fail + sub $I11, rx640_pos, rx640_off + substr $S10, rx640_tgt, $I11, 1 + ne $S10, "(", rx640_fail + add rx640_pos, 1 # rx subrule "ws" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."ws"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."ws"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() # rx subrule "signature" subtype=capture negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."signature"() - unless $P10, rx631_fail - rx631_cur."!mark_push"(0, -1, 0, $P10) + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."signature"() + unless $P10, rx640_fail + rx640_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("signature") - rx631_pos = $P10."pos"() + rx640_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."ws"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."ws"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() # rx literal ")" - add $I11, rx631_pos, 1 - gt $I11, rx631_eos, rx631_fail - sub $I11, rx631_pos, rx631_off - substr $S10, rx631_tgt, $I11, 1 - ne $S10, ")", rx631_fail - add rx631_pos, 1 + add $I11, rx640_pos, 1 + gt $I11, rx640_eos, rx640_fail + sub $I11, rx640_pos, rx640_off + substr $S10, rx640_tgt, $I11, 1 + ne $S10, ")", rx640_fail + add rx640_pos, 1 # rx subrule "ws" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."ws"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() - goto alt645_end - alt645_1: -.annotate 'line', 297 + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."ws"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() + goto alt654_end + alt654_1: +.annotate 'line', 299 # rx subrule "ws" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."ws"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."ws"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() # rx subrule "panic" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."panic"("Routine declaration requires a signature") - unless $P10, rx631_fail - rx631_pos = $P10."pos"() + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."panic"("Routine declaration requires a signature") + unless $P10, rx640_fail + rx640_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."ws"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() - alt645_end: + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."ws"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() + alt654_end: # rx subrule "ws" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."ws"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() -.annotate 'line', 298 + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."ws"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() +.annotate 'line', 300 # rx subrule "blockoid" subtype=capture negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."blockoid"() - unless $P10, rx631_fail - rx631_cur."!mark_push"(0, -1, 0, $P10) + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."blockoid"() + unless $P10, rx640_fail + rx640_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("blockoid") - rx631_pos = $P10."pos"() + rx640_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx631_cur."!cursor_pos"(rx631_pos) - $P10 = rx631_cur."ws"() - unless $P10, rx631_fail - rx631_pos = $P10."pos"() -.annotate 'line', 293 + rx640_cur."!cursor_pos"(rx640_pos) + $P10 = rx640_cur."ws"() + unless $P10, rx640_fail + rx640_pos = $P10."pos"() +.annotate 'line', 295 # rx pass - rx631_cur."!cursor_pass"(rx631_pos, "routine_def") - rx631_cur."!cursor_debug"("PASS ", "routine_def", " at pos=", rx631_pos) - .return (rx631_cur) - rx631_fail: -.annotate 'line', 4 - (rx631_rep, rx631_pos, $I10, $P10) = rx631_cur."!mark_fail"(0) - lt rx631_pos, -1, rx631_done - eq rx631_pos, -1, rx631_fail + rx640_cur."!cursor_pass"(rx640_pos, "routine_def") + rx640_cur."!cursor_debug"("PASS ", "routine_def", " at pos=", rx640_pos) + .return (rx640_cur) + rx640_fail: +.annotate 'line', 4 + (rx640_rep, rx640_pos, $I10, $P10) = rx640_cur."!mark_fail"(0) + lt rx640_pos, -1, rx640_done + eq rx640_pos, -1, rx640_fail jump $I10 - rx631_done: - rx631_cur."!cursor_fail"() - rx631_cur."!cursor_debug"("FAIL ", "routine_def") - .return (rx631_cur) + rx640_done: + rx640_cur."!cursor_fail"() + rx640_cur."!cursor_debug"("FAIL ", "routine_def") + .return (rx640_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__routine_def" :subid("156_1275511697.61926") :method +.sub "!PREFIX__routine_def" :subid("159_1275600007.84296") :method .annotate 'line', 4 - new $P633, "ResizablePMCArray" - push $P633, "" - .return ($P633) + new $P642, "ResizablePMCArray" + push $P642, "" + .return ($P642) .end .namespace ["NQP";"Grammar"] -.sub "method_def" :subid("157_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "method_def" :subid("160_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx655_tgt - .local int rx655_pos - .local int rx655_off - .local int rx655_eos - .local int rx655_rep - .local pmc rx655_cur - (rx655_cur, rx655_pos, rx655_tgt) = self."!cursor_start"() - rx655_cur."!cursor_debug"("START ", "method_def") - rx655_cur."!cursor_caparray"("deflongname") - .lex unicode:"$\x{a2}", rx655_cur + .local string rx664_tgt + .local int rx664_pos + .local int rx664_off + .local int rx664_eos + .local int rx664_rep + .local pmc rx664_cur + (rx664_cur, rx664_pos, rx664_tgt) = self."!cursor_start"() + rx664_cur."!cursor_debug"("START ", "method_def") + rx664_cur."!cursor_caparray"("deflongname") + .lex unicode:"$\x{a2}", rx664_cur .local pmc match .lex "$/", match - length rx655_eos, rx655_tgt - gt rx655_pos, rx655_eos, rx655_done - set rx655_off, 0 - lt rx655_pos, 2, rx655_start - sub rx655_off, rx655_pos, 1 - substr rx655_tgt, rx655_tgt, rx655_off - rx655_start: + length rx664_eos, rx664_tgt + gt rx664_pos, rx664_eos, rx664_done + set rx664_off, 0 + lt rx664_pos, 2, rx664_start + sub rx664_off, rx664_pos, 1 + substr rx664_tgt, rx664_tgt, rx664_off + rx664_start: $I10 = self.'from'() - ne $I10, -1, rxscan658_done - goto rxscan658_scan - rxscan658_loop: - ($P10) = rx655_cur."from"() + ne $I10, -1, rxscan667_done + goto rxscan667_scan + rxscan667_loop: + ($P10) = rx664_cur."from"() inc $P10 - set rx655_pos, $P10 - ge rx655_pos, rx655_eos, rxscan658_done - rxscan658_scan: - set_addr $I10, rxscan658_loop - rx655_cur."!mark_push"(0, rx655_pos, $I10) - rxscan658_done: -.annotate 'line', 301 + set rx664_pos, $P10 + ge rx664_pos, rx664_eos, rxscan667_done + rxscan667_scan: + set_addr $I10, rxscan667_loop + rx664_cur."!mark_push"(0, rx664_pos, $I10) + rxscan667_done: +.annotate 'line', 303 # rx subrule "ws" subtype=method negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."ws"() - unless $P10, rx655_fail - rx655_pos = $P10."pos"() -.annotate 'line', 302 - # rx rxquantr660 ** 0..1 - set_addr $I661, rxquantr660_done - rx655_cur."!mark_push"(0, rx655_pos, $I661) - rxquantr660_loop: + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."ws"() + unless $P10, rx664_fail + rx664_pos = $P10."pos"() +.annotate 'line', 304 + # rx rxquantr669 ** 0..1 + set_addr $I670, rxquantr669_done + rx664_cur."!mark_push"(0, rx664_pos, $I670) + rxquantr669_loop: # rx subrule "deflongname" subtype=capture negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."deflongname"() - unless $P10, rx655_fail - rx655_cur."!mark_push"(0, -1, 0, $P10) + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."deflongname"() + unless $P10, rx664_fail + rx664_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("deflongname") - rx655_pos = $P10."pos"() - (rx655_rep) = rx655_cur."!mark_commit"($I661) - rxquantr660_done: + rx664_pos = $P10."pos"() + (rx664_rep) = rx664_cur."!mark_commit"($I670) + rxquantr669_done: # rx subrule "ws" subtype=method negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."ws"() - unless $P10, rx655_fail - rx655_pos = $P10."pos"() -.annotate 'line', 303 + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."ws"() + unless $P10, rx664_fail + rx664_pos = $P10."pos"() +.annotate 'line', 305 # rx subrule "newpad" subtype=method negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."newpad"() - unless $P10, rx655_fail - rx655_pos = $P10."pos"() + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."newpad"() + unless $P10, rx664_fail + rx664_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."ws"() - unless $P10, rx655_fail - rx655_pos = $P10."pos"() - alt664_0: -.annotate 'line', 304 - set_addr $I10, alt664_1 - rx655_cur."!mark_push"(0, rx655_pos, $I10) + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."ws"() + unless $P10, rx664_fail + rx664_pos = $P10."pos"() + alt673_0: +.annotate 'line', 306 + set_addr $I10, alt673_1 + rx664_cur."!mark_push"(0, rx664_pos, $I10) # rx subrule "ws" subtype=method negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."ws"() - unless $P10, rx655_fail - rx655_pos = $P10."pos"() + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."ws"() + unless $P10, rx664_fail + rx664_pos = $P10."pos"() # rx literal "(" - add $I11, rx655_pos, 1 - gt $I11, rx655_eos, rx655_fail - sub $I11, rx655_pos, rx655_off - substr $S10, rx655_tgt, $I11, 1 - ne $S10, "(", rx655_fail - add rx655_pos, 1 + add $I11, rx664_pos, 1 + gt $I11, rx664_eos, rx664_fail + sub $I11, rx664_pos, rx664_off + substr $S10, rx664_tgt, $I11, 1 + ne $S10, "(", rx664_fail + add rx664_pos, 1 # rx subrule "ws" subtype=method negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."ws"() - unless $P10, rx655_fail - rx655_pos = $P10."pos"() + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."ws"() + unless $P10, rx664_fail + rx664_pos = $P10."pos"() # rx subrule "signature" subtype=capture negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."signature"() - unless $P10, rx655_fail - rx655_cur."!mark_push"(0, -1, 0, $P10) + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."signature"() + unless $P10, rx664_fail + rx664_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("signature") - rx655_pos = $P10."pos"() + rx664_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."ws"() - unless $P10, rx655_fail - rx655_pos = $P10."pos"() + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."ws"() + unless $P10, rx664_fail + rx664_pos = $P10."pos"() # rx literal ")" - add $I11, rx655_pos, 1 - gt $I11, rx655_eos, rx655_fail - sub $I11, rx655_pos, rx655_off - substr $S10, rx655_tgt, $I11, 1 - ne $S10, ")", rx655_fail - add rx655_pos, 1 + add $I11, rx664_pos, 1 + gt $I11, rx664_eos, rx664_fail + sub $I11, rx664_pos, rx664_off + substr $S10, rx664_tgt, $I11, 1 + ne $S10, ")", rx664_fail + add rx664_pos, 1 # rx subrule "ws" subtype=method negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."ws"() - unless $P10, rx655_fail - rx655_pos = $P10."pos"() - goto alt664_end - alt664_1: -.annotate 'line', 305 + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."ws"() + unless $P10, rx664_fail + rx664_pos = $P10."pos"() + goto alt673_end + alt673_1: +.annotate 'line', 307 # rx subrule "ws" subtype=method negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."ws"() - unless $P10, rx655_fail - rx655_pos = $P10."pos"() + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."ws"() + unless $P10, rx664_fail + rx664_pos = $P10."pos"() # rx subrule "panic" subtype=method negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."panic"("Routine declaration requires a signature") - unless $P10, rx655_fail - rx655_pos = $P10."pos"() + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."panic"("Routine declaration requires a signature") + unless $P10, rx664_fail + rx664_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."ws"() - unless $P10, rx655_fail - rx655_pos = $P10."pos"() - alt664_end: + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."ws"() + unless $P10, rx664_fail + rx664_pos = $P10."pos"() + alt673_end: # rx subrule "ws" subtype=method negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."ws"() - unless $P10, rx655_fail - rx655_pos = $P10."pos"() -.annotate 'line', 306 + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."ws"() + unless $P10, rx664_fail + rx664_pos = $P10."pos"() +.annotate 'line', 308 # rx subrule "blockoid" subtype=capture negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."blockoid"() - unless $P10, rx655_fail - rx655_cur."!mark_push"(0, -1, 0, $P10) + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."blockoid"() + unless $P10, rx664_fail + rx664_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("blockoid") - rx655_pos = $P10."pos"() + rx664_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx655_cur."!cursor_pos"(rx655_pos) - $P10 = rx655_cur."ws"() - unless $P10, rx655_fail - rx655_pos = $P10."pos"() -.annotate 'line', 301 + rx664_cur."!cursor_pos"(rx664_pos) + $P10 = rx664_cur."ws"() + unless $P10, rx664_fail + rx664_pos = $P10."pos"() +.annotate 'line', 303 # rx pass - rx655_cur."!cursor_pass"(rx655_pos, "method_def") - rx655_cur."!cursor_debug"("PASS ", "method_def", " at pos=", rx655_pos) - .return (rx655_cur) - rx655_fail: -.annotate 'line', 4 - (rx655_rep, rx655_pos, $I10, $P10) = rx655_cur."!mark_fail"(0) - lt rx655_pos, -1, rx655_done - eq rx655_pos, -1, rx655_fail + rx664_cur."!cursor_pass"(rx664_pos, "method_def") + rx664_cur."!cursor_debug"("PASS ", "method_def", " at pos=", rx664_pos) + .return (rx664_cur) + rx664_fail: +.annotate 'line', 4 + (rx664_rep, rx664_pos, $I10, $P10) = rx664_cur."!mark_fail"(0) + lt rx664_pos, -1, rx664_done + eq rx664_pos, -1, rx664_fail jump $I10 - rx655_done: - rx655_cur."!cursor_fail"() - rx655_cur."!cursor_debug"("FAIL ", "method_def") - .return (rx655_cur) + rx664_done: + rx664_cur."!cursor_fail"() + rx664_cur."!cursor_debug"("FAIL ", "method_def") + .return (rx664_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__method_def" :subid("158_1275511697.61926") :method +.sub "!PREFIX__method_def" :subid("161_1275600007.84296") :method .annotate 'line', 4 - new $P657, "ResizablePMCArray" - push $P657, "" - .return ($P657) + new $P666, "ResizablePMCArray" + push $P666, "" + .return ($P666) .end .namespace ["NQP";"Grammar"] -.sub "signature" :subid("159_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 4 - .local string rx674_tgt - .local int rx674_pos - .local int rx674_off - .local int rx674_eos - .local int rx674_rep - .local pmc rx674_cur - (rx674_cur, rx674_pos, rx674_tgt) = self."!cursor_start"() - rx674_cur."!cursor_debug"("START ", "signature") - rx674_cur."!cursor_caparray"("parameter") - .lex unicode:"$\x{a2}", rx674_cur +.sub "multi_declarator" :subid("162_1275600007.84296") :method +.annotate 'line', 311 + $P683 = self."!protoregex"("multi_declarator") + .return ($P683) +.end + + +.namespace ["NQP";"Grammar"] +.sub "!PREFIX__multi_declarator" :subid("163_1275600007.84296") :method +.annotate 'line', 311 + $P685 = self."!PREFIX__!protoregex"("multi_declarator") + .return ($P685) +.end + + +.namespace ["NQP";"Grammar"] +.sub "multi_declarator:sym" :subid("164_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 313 + new $P687, "Undef" + .lex "$*MULTINESS", $P687 +.annotate 'line', 4 + .local string rx688_tgt + .local int rx688_pos + .local int rx688_off + .local int rx688_eos + .local int rx688_rep + .local pmc rx688_cur + (rx688_cur, rx688_pos, rx688_tgt) = self."!cursor_start"() + rx688_cur."!cursor_debug"("START ", "multi_declarator:sym") + .lex unicode:"$\x{a2}", rx688_cur .local pmc match .lex "$/", match - length rx674_eos, rx674_tgt - gt rx674_pos, rx674_eos, rx674_done - set rx674_off, 0 - lt rx674_pos, 2, rx674_start - sub rx674_off, rx674_pos, 1 - substr rx674_tgt, rx674_tgt, rx674_off - rx674_start: + length rx688_eos, rx688_tgt + gt rx688_pos, rx688_eos, rx688_done + set rx688_off, 0 + lt rx688_pos, 2, rx688_start + sub rx688_off, rx688_pos, 1 + substr rx688_tgt, rx688_tgt, rx688_off + rx688_start: $I10 = self.'from'() - ne $I10, -1, rxscan677_done - goto rxscan677_scan - rxscan677_loop: - ($P10) = rx674_cur."from"() + ne $I10, -1, rxscan691_done + goto rxscan691_scan + rxscan691_loop: + ($P10) = rx688_cur."from"() inc $P10 - set rx674_pos, $P10 - ge rx674_pos, rx674_eos, rxscan677_done - rxscan677_scan: - set_addr $I10, rxscan677_loop - rx674_cur."!mark_push"(0, rx674_pos, $I10) - rxscan677_done: -.annotate 'line', 309 - # rx rxquantr678 ** 0..1 - set_addr $I681, rxquantr678_done - rx674_cur."!mark_push"(0, rx674_pos, $I681) - rxquantr678_loop: - # rx rxquantr679 ** 1..* - set_addr $I680, rxquantr679_done - rx674_cur."!mark_push"(0, -1, $I680) - rxquantr679_loop: - # rx subrule "ws" subtype=method negate= - rx674_cur."!cursor_pos"(rx674_pos) - $P10 = rx674_cur."ws"() - unless $P10, rx674_fail - rx674_pos = $P10."pos"() - # rx subrule "parameter" subtype=capture negate= - rx674_cur."!cursor_pos"(rx674_pos) - $P10 = rx674_cur."parameter"() - unless $P10, rx674_fail - rx674_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("parameter") - rx674_pos = $P10."pos"() + set rx688_pos, $P10 + ge rx688_pos, rx688_eos, rxscan691_done + rxscan691_scan: + set_addr $I10, rxscan691_loop + rx688_cur."!mark_push"(0, rx688_pos, $I10) + rxscan691_done: +.annotate 'line', 313 + # rx subcapture "sym" + set_addr $I10, rxcap_692_fail + rx688_cur."!mark_push"(0, rx688_pos, $I10) + # rx literal "multi" + add $I11, rx688_pos, 5 + gt $I11, rx688_eos, rx688_fail + sub $I11, rx688_pos, rx688_off + substr $S10, rx688_tgt, $I11, 5 + ne $S10, "multi", rx688_fail + add rx688_pos, 5 + set_addr $I10, rxcap_692_fail + ($I12, $I11) = rx688_cur."!mark_peek"($I10) + rx688_cur."!cursor_pos"($I11) + ($P10) = rx688_cur."!cursor_start"() + $P10."!cursor_pass"(rx688_pos, "") + rx688_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("sym") + goto rxcap_692_done + rxcap_692_fail: + goto rx688_fail + rxcap_692_done: + rx688_cur."!cursor_pos"(rx688_pos) + new $P693, "String" + assign $P693, "multi" + store_lex "$*MULTINESS", $P693 +.annotate 'line', 314 # rx subrule "ws" subtype=method negate= - rx674_cur."!cursor_pos"(rx674_pos) - $P10 = rx674_cur."ws"() - unless $P10, rx674_fail - rx674_pos = $P10."pos"() - (rx674_rep) = rx674_cur."!mark_commit"($I680) - rx674_cur."!mark_push"(rx674_rep, rx674_pos, $I680) - # rx literal "," - add $I11, rx674_pos, 1 - gt $I11, rx674_eos, rx674_fail - sub $I11, rx674_pos, rx674_off - substr $S10, rx674_tgt, $I11, 1 - ne $S10, ",", rx674_fail - add rx674_pos, 1 - goto rxquantr679_loop - rxquantr679_done: - (rx674_rep) = rx674_cur."!mark_commit"($I681) - rxquantr678_done: + rx688_cur."!cursor_pos"(rx688_pos) + $P10 = rx688_cur."ws"() + unless $P10, rx688_fail + rx688_pos = $P10."pos"() + alt694_0: + set_addr $I10, alt694_1 + rx688_cur."!mark_push"(0, rx688_pos, $I10) + # rx subrule "declarator" subtype=capture negate= + rx688_cur."!cursor_pos"(rx688_pos) + $P10 = rx688_cur."declarator"() + unless $P10, rx688_fail + rx688_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("declarator") + rx688_pos = $P10."pos"() + goto alt694_end + alt694_1: + set_addr $I10, alt694_2 + rx688_cur."!mark_push"(0, rx688_pos, $I10) + # rx subrule "routine_def" subtype=capture negate= + rx688_cur."!cursor_pos"(rx688_pos) + $P10 = rx688_cur."routine_def"() + unless $P10, rx688_fail + rx688_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("routine_def") + rx688_pos = $P10."pos"() + goto alt694_end + alt694_2: + # rx subrule "panic" subtype=method negate= + rx688_cur."!cursor_pos"(rx688_pos) + $P10 = rx688_cur."panic"("Malformed multi") + unless $P10, rx688_fail + rx688_pos = $P10."pos"() + alt694_end: +.annotate 'line', 312 # rx pass - rx674_cur."!cursor_pass"(rx674_pos, "signature") - rx674_cur."!cursor_debug"("PASS ", "signature", " at pos=", rx674_pos) - .return (rx674_cur) - rx674_fail: -.annotate 'line', 4 - (rx674_rep, rx674_pos, $I10, $P10) = rx674_cur."!mark_fail"(0) - lt rx674_pos, -1, rx674_done - eq rx674_pos, -1, rx674_fail + rx688_cur."!cursor_pass"(rx688_pos, "multi_declarator:sym") + rx688_cur."!cursor_debug"("PASS ", "multi_declarator:sym", " at pos=", rx688_pos) + .return (rx688_cur) + rx688_fail: +.annotate 'line', 4 + (rx688_rep, rx688_pos, $I10, $P10) = rx688_cur."!mark_fail"(0) + lt rx688_pos, -1, rx688_done + eq rx688_pos, -1, rx688_fail jump $I10 - rx674_done: - rx674_cur."!cursor_fail"() - rx674_cur."!cursor_debug"("FAIL ", "signature") - .return (rx674_cur) + rx688_done: + rx688_cur."!cursor_fail"() + rx688_cur."!cursor_debug"("FAIL ", "multi_declarator:sym") + .return (rx688_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__signature" :subid("160_1275511697.61926") :method +.sub "!PREFIX__multi_declarator:sym" :subid("165_1275600007.84296") :method .annotate 'line', 4 - new $P676, "ResizablePMCArray" - push $P676, "" - .return ($P676) + new $P690, "ResizablePMCArray" + push $P690, "multi" + .return ($P690) .end .namespace ["NQP";"Grammar"] -.sub "parameter" :subid("161_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "multi_declarator:sym" :subid("166_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 317 + new $P696, "Undef" + .lex "$*MULTINESS", $P696 .annotate 'line', 4 - .local string rx683_tgt - .local int rx683_pos - .local int rx683_off - .local int rx683_eos - .local int rx683_rep - .local pmc rx683_cur - (rx683_cur, rx683_pos, rx683_tgt) = self."!cursor_start"() - rx683_cur."!cursor_debug"("START ", "parameter") - rx683_cur."!cursor_caparray"("typename", "default_value") - .lex unicode:"$\x{a2}", rx683_cur - .local pmc match - .lex "$/", match - length rx683_eos, rx683_tgt - gt rx683_pos, rx683_eos, rx683_done - set rx683_off, 0 - lt rx683_pos, 2, rx683_start - sub rx683_off, rx683_pos, 1 - substr rx683_tgt, rx683_tgt, rx683_off - rx683_start: - $I10 = self.'from'() - ne $I10, -1, rxscan686_done - goto rxscan686_scan - rxscan686_loop: - ($P10) = rx683_cur."from"() + .local string rx697_tgt + .local int rx697_pos + .local int rx697_off + .local int rx697_eos + .local int rx697_rep + .local pmc rx697_cur + (rx697_cur, rx697_pos, rx697_tgt) = self."!cursor_start"() + rx697_cur."!cursor_debug"("START ", "multi_declarator:sym") + .lex unicode:"$\x{a2}", rx697_cur + .local pmc match + .lex "$/", match + length rx697_eos, rx697_tgt + gt rx697_pos, rx697_eos, rx697_done + set rx697_off, 0 + lt rx697_pos, 2, rx697_start + sub rx697_off, rx697_pos, 1 + substr rx697_tgt, rx697_tgt, rx697_off + rx697_start: + $I10 = self.'from'() + ne $I10, -1, rxscan700_done + goto rxscan700_scan + rxscan700_loop: + ($P10) = rx697_cur."from"() inc $P10 - set rx683_pos, $P10 - ge rx683_pos, rx683_eos, rxscan686_done - rxscan686_scan: - set_addr $I10, rxscan686_loop - rx683_cur."!mark_push"(0, rx683_pos, $I10) - rxscan686_done: -.annotate 'line', 312 - # rx rxquantr687 ** 0..* - set_addr $I688, rxquantr687_done - rx683_cur."!mark_push"(0, rx683_pos, $I688) - rxquantr687_loop: + set rx697_pos, $P10 + ge rx697_pos, rx697_eos, rxscan700_done + rxscan700_scan: + set_addr $I10, rxscan700_loop + rx697_cur."!mark_push"(0, rx697_pos, $I10) + rxscan700_done: +.annotate 'line', 316 + rx697_cur."!cursor_pos"(rx697_pos) +.annotate 'line', 317 + new $P701, "String" + assign $P701, "" + store_lex "$*MULTINESS", $P701 +.annotate 'line', 318 + # rx subrule "declarator" subtype=capture negate= + rx697_cur."!cursor_pos"(rx697_pos) + $P10 = rx697_cur."declarator"() + unless $P10, rx697_fail + rx697_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("declarator") + rx697_pos = $P10."pos"() +.annotate 'line', 316 + # rx pass + rx697_cur."!cursor_pass"(rx697_pos, "multi_declarator:sym") + rx697_cur."!cursor_debug"("PASS ", "multi_declarator:sym", " at pos=", rx697_pos) + .return (rx697_cur) + rx697_fail: +.annotate 'line', 4 + (rx697_rep, rx697_pos, $I10, $P10) = rx697_cur."!mark_fail"(0) + lt rx697_pos, -1, rx697_done + eq rx697_pos, -1, rx697_fail + jump $I10 + rx697_done: + rx697_cur."!cursor_fail"() + rx697_cur."!cursor_debug"("FAIL ", "multi_declarator:sym") + .return (rx697_cur) + .return () +.end + + +.namespace ["NQP";"Grammar"] +.sub "!PREFIX__multi_declarator:sym" :subid("167_1275600007.84296") :method +.annotate 'line', 4 + new $P699, "ResizablePMCArray" + push $P699, "" + .return ($P699) +.end + + +.namespace ["NQP";"Grammar"] +.sub "signature" :subid("168_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 4 + .local string rx703_tgt + .local int rx703_pos + .local int rx703_off + .local int rx703_eos + .local int rx703_rep + .local pmc rx703_cur + (rx703_cur, rx703_pos, rx703_tgt) = self."!cursor_start"() + rx703_cur."!cursor_debug"("START ", "signature") + rx703_cur."!cursor_caparray"("parameter") + .lex unicode:"$\x{a2}", rx703_cur + .local pmc match + .lex "$/", match + length rx703_eos, rx703_tgt + gt rx703_pos, rx703_eos, rx703_done + set rx703_off, 0 + lt rx703_pos, 2, rx703_start + sub rx703_off, rx703_pos, 1 + substr rx703_tgt, rx703_tgt, rx703_off + rx703_start: + $I10 = self.'from'() + ne $I10, -1, rxscan706_done + goto rxscan706_scan + rxscan706_loop: + ($P10) = rx703_cur."from"() + inc $P10 + set rx703_pos, $P10 + ge rx703_pos, rx703_eos, rxscan706_done + rxscan706_scan: + set_addr $I10, rxscan706_loop + rx703_cur."!mark_push"(0, rx703_pos, $I10) + rxscan706_done: +.annotate 'line', 321 + # rx rxquantr707 ** 0..1 + set_addr $I710, rxquantr707_done + rx703_cur."!mark_push"(0, rx703_pos, $I710) + rxquantr707_loop: + # rx rxquantr708 ** 1..* + set_addr $I709, rxquantr708_done + rx703_cur."!mark_push"(0, -1, $I709) + rxquantr708_loop: + # rx subrule "ws" subtype=method negate= + rx703_cur."!cursor_pos"(rx703_pos) + $P10 = rx703_cur."ws"() + unless $P10, rx703_fail + rx703_pos = $P10."pos"() + # rx subrule "parameter" subtype=capture negate= + rx703_cur."!cursor_pos"(rx703_pos) + $P10 = rx703_cur."parameter"() + unless $P10, rx703_fail + rx703_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("parameter") + rx703_pos = $P10."pos"() + # rx subrule "ws" subtype=method negate= + rx703_cur."!cursor_pos"(rx703_pos) + $P10 = rx703_cur."ws"() + unless $P10, rx703_fail + rx703_pos = $P10."pos"() + (rx703_rep) = rx703_cur."!mark_commit"($I709) + rx703_cur."!mark_push"(rx703_rep, rx703_pos, $I709) + # rx literal "," + add $I11, rx703_pos, 1 + gt $I11, rx703_eos, rx703_fail + sub $I11, rx703_pos, rx703_off + substr $S10, rx703_tgt, $I11, 1 + ne $S10, ",", rx703_fail + add rx703_pos, 1 + goto rxquantr708_loop + rxquantr708_done: + (rx703_rep) = rx703_cur."!mark_commit"($I710) + rxquantr707_done: + # rx pass + rx703_cur."!cursor_pass"(rx703_pos, "signature") + rx703_cur."!cursor_debug"("PASS ", "signature", " at pos=", rx703_pos) + .return (rx703_cur) + rx703_fail: +.annotate 'line', 4 + (rx703_rep, rx703_pos, $I10, $P10) = rx703_cur."!mark_fail"(0) + lt rx703_pos, -1, rx703_done + eq rx703_pos, -1, rx703_fail + jump $I10 + rx703_done: + rx703_cur."!cursor_fail"() + rx703_cur."!cursor_debug"("FAIL ", "signature") + .return (rx703_cur) + .return () +.end + + +.namespace ["NQP";"Grammar"] +.sub "!PREFIX__signature" :subid("169_1275600007.84296") :method +.annotate 'line', 4 + new $P705, "ResizablePMCArray" + push $P705, "" + .return ($P705) +.end + + +.namespace ["NQP";"Grammar"] +.sub "parameter" :subid("170_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 4 + .local string rx712_tgt + .local int rx712_pos + .local int rx712_off + .local int rx712_eos + .local int rx712_rep + .local pmc rx712_cur + (rx712_cur, rx712_pos, rx712_tgt) = self."!cursor_start"() + rx712_cur."!cursor_debug"("START ", "parameter") + rx712_cur."!cursor_caparray"("default_value", "typename") + .lex unicode:"$\x{a2}", rx712_cur + .local pmc match + .lex "$/", match + length rx712_eos, rx712_tgt + gt rx712_pos, rx712_eos, rx712_done + set rx712_off, 0 + lt rx712_pos, 2, rx712_start + sub rx712_off, rx712_pos, 1 + substr rx712_tgt, rx712_tgt, rx712_off + rx712_start: + $I10 = self.'from'() + ne $I10, -1, rxscan715_done + goto rxscan715_scan + rxscan715_loop: + ($P10) = rx712_cur."from"() + inc $P10 + set rx712_pos, $P10 + ge rx712_pos, rx712_eos, rxscan715_done + rxscan715_scan: + set_addr $I10, rxscan715_loop + rx712_cur."!mark_push"(0, rx712_pos, $I10) + rxscan715_done: +.annotate 'line', 324 + # rx rxquantr716 ** 0..* + set_addr $I717, rxquantr716_done + rx712_cur."!mark_push"(0, rx712_pos, $I717) + rxquantr716_loop: # rx subrule "typename" subtype=capture negate= - rx683_cur."!cursor_pos"(rx683_pos) - $P10 = rx683_cur."typename"() - unless $P10, rx683_fail - rx683_cur."!mark_push"(0, -1, 0, $P10) + rx712_cur."!cursor_pos"(rx712_pos) + $P10 = rx712_cur."typename"() + unless $P10, rx712_fail + rx712_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("typename") - rx683_pos = $P10."pos"() + rx712_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx683_cur."!cursor_pos"(rx683_pos) - $P10 = rx683_cur."ws"() - unless $P10, rx683_fail - rx683_pos = $P10."pos"() - (rx683_rep) = rx683_cur."!mark_commit"($I688) - rx683_cur."!mark_push"(rx683_rep, rx683_pos, $I688) - goto rxquantr687_loop - rxquantr687_done: - alt689_0: -.annotate 'line', 313 - set_addr $I10, alt689_1 - rx683_cur."!mark_push"(0, rx683_pos, $I10) -.annotate 'line', 314 + rx712_cur."!cursor_pos"(rx712_pos) + $P10 = rx712_cur."ws"() + unless $P10, rx712_fail + rx712_pos = $P10."pos"() + (rx712_rep) = rx712_cur."!mark_commit"($I717) + rx712_cur."!mark_push"(rx712_rep, rx712_pos, $I717) + goto rxquantr716_loop + rxquantr716_done: + alt718_0: +.annotate 'line', 325 + set_addr $I10, alt718_1 + rx712_cur."!mark_push"(0, rx712_pos, $I10) +.annotate 'line', 326 # rx subcapture "quant" - set_addr $I10, rxcap_690_fail - rx683_cur."!mark_push"(0, rx683_pos, $I10) + set_addr $I10, rxcap_719_fail + rx712_cur."!mark_push"(0, rx712_pos, $I10) # rx literal "*" - add $I11, rx683_pos, 1 - gt $I11, rx683_eos, rx683_fail - sub $I11, rx683_pos, rx683_off - substr $S10, rx683_tgt, $I11, 1 - ne $S10, "*", rx683_fail - add rx683_pos, 1 - set_addr $I10, rxcap_690_fail - ($I12, $I11) = rx683_cur."!mark_peek"($I10) - rx683_cur."!cursor_pos"($I11) - ($P10) = rx683_cur."!cursor_start"() - $P10."!cursor_pass"(rx683_pos, "") - rx683_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx712_pos, 1 + gt $I11, rx712_eos, rx712_fail + sub $I11, rx712_pos, rx712_off + substr $S10, rx712_tgt, $I11, 1 + ne $S10, "*", rx712_fail + add rx712_pos, 1 + set_addr $I10, rxcap_719_fail + ($I12, $I11) = rx712_cur."!mark_peek"($I10) + rx712_cur."!cursor_pos"($I11) + ($P10) = rx712_cur."!cursor_start"() + $P10."!cursor_pass"(rx712_pos, "") + rx712_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quant") - goto rxcap_690_done - rxcap_690_fail: - goto rx683_fail - rxcap_690_done: + goto rxcap_719_done + rxcap_719_fail: + goto rx712_fail + rxcap_719_done: # rx subrule "param_var" subtype=capture negate= - rx683_cur."!cursor_pos"(rx683_pos) - $P10 = rx683_cur."param_var"() - unless $P10, rx683_fail - rx683_cur."!mark_push"(0, -1, 0, $P10) + rx712_cur."!cursor_pos"(rx712_pos) + $P10 = rx712_cur."param_var"() + unless $P10, rx712_fail + rx712_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("param_var") - rx683_pos = $P10."pos"() - goto alt689_end - alt689_1: - alt691_0: -.annotate 'line', 315 - set_addr $I10, alt691_1 - rx683_cur."!mark_push"(0, rx683_pos, $I10) + rx712_pos = $P10."pos"() + goto alt718_end + alt718_1: + alt720_0: +.annotate 'line', 327 + set_addr $I10, alt720_1 + rx712_cur."!mark_push"(0, rx712_pos, $I10) # rx subrule "param_var" subtype=capture negate= - rx683_cur."!cursor_pos"(rx683_pos) - $P10 = rx683_cur."param_var"() - unless $P10, rx683_fail - rx683_cur."!mark_push"(0, -1, 0, $P10) + rx712_cur."!cursor_pos"(rx712_pos) + $P10 = rx712_cur."param_var"() + unless $P10, rx712_fail + rx712_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("param_var") - rx683_pos = $P10."pos"() - goto alt691_end - alt691_1: + rx712_pos = $P10."pos"() + goto alt720_end + alt720_1: # rx subrule "named_param" subtype=capture negate= - rx683_cur."!cursor_pos"(rx683_pos) - $P10 = rx683_cur."named_param"() - unless $P10, rx683_fail - rx683_cur."!mark_push"(0, -1, 0, $P10) + rx712_cur."!cursor_pos"(rx712_pos) + $P10 = rx712_cur."named_param"() + unless $P10, rx712_fail + rx712_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("named_param") - rx683_pos = $P10."pos"() - alt691_end: + rx712_pos = $P10."pos"() + alt720_end: # rx subcapture "quant" - set_addr $I10, rxcap_693_fail - rx683_cur."!mark_push"(0, rx683_pos, $I10) - alt692_0: - set_addr $I10, alt692_1 - rx683_cur."!mark_push"(0, rx683_pos, $I10) + set_addr $I10, rxcap_722_fail + rx712_cur."!mark_push"(0, rx712_pos, $I10) + alt721_0: + set_addr $I10, alt721_1 + rx712_cur."!mark_push"(0, rx712_pos, $I10) # rx literal "?" - add $I11, rx683_pos, 1 - gt $I11, rx683_eos, rx683_fail - sub $I11, rx683_pos, rx683_off - substr $S10, rx683_tgt, $I11, 1 - ne $S10, "?", rx683_fail - add rx683_pos, 1 - goto alt692_end - alt692_1: - set_addr $I10, alt692_2 - rx683_cur."!mark_push"(0, rx683_pos, $I10) + add $I11, rx712_pos, 1 + gt $I11, rx712_eos, rx712_fail + sub $I11, rx712_pos, rx712_off + substr $S10, rx712_tgt, $I11, 1 + ne $S10, "?", rx712_fail + add rx712_pos, 1 + goto alt721_end + alt721_1: + set_addr $I10, alt721_2 + rx712_cur."!mark_push"(0, rx712_pos, $I10) # rx literal "!" - add $I11, rx683_pos, 1 - gt $I11, rx683_eos, rx683_fail - sub $I11, rx683_pos, rx683_off - substr $S10, rx683_tgt, $I11, 1 - ne $S10, "!", rx683_fail - add rx683_pos, 1 - goto alt692_end - alt692_2: - alt692_end: - set_addr $I10, rxcap_693_fail - ($I12, $I11) = rx683_cur."!mark_peek"($I10) - rx683_cur."!cursor_pos"($I11) - ($P10) = rx683_cur."!cursor_start"() - $P10."!cursor_pass"(rx683_pos, "") - rx683_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx712_pos, 1 + gt $I11, rx712_eos, rx712_fail + sub $I11, rx712_pos, rx712_off + substr $S10, rx712_tgt, $I11, 1 + ne $S10, "!", rx712_fail + add rx712_pos, 1 + goto alt721_end + alt721_2: + alt721_end: + set_addr $I10, rxcap_722_fail + ($I12, $I11) = rx712_cur."!mark_peek"($I10) + rx712_cur."!cursor_pos"($I11) + ($P10) = rx712_cur."!cursor_start"() + $P10."!cursor_pass"(rx712_pos, "") + rx712_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quant") - goto rxcap_693_done - rxcap_693_fail: - goto rx683_fail - rxcap_693_done: - alt689_end: -.annotate 'line', 317 - # rx rxquantr694 ** 0..1 - set_addr $I695, rxquantr694_done - rx683_cur."!mark_push"(0, rx683_pos, $I695) - rxquantr694_loop: + goto rxcap_722_done + rxcap_722_fail: + goto rx712_fail + rxcap_722_done: + alt718_end: +.annotate 'line', 329 + # rx rxquantr723 ** 0..1 + set_addr $I724, rxquantr723_done + rx712_cur."!mark_push"(0, rx712_pos, $I724) + rxquantr723_loop: # rx subrule "default_value" subtype=capture negate= - rx683_cur."!cursor_pos"(rx683_pos) - $P10 = rx683_cur."default_value"() - unless $P10, rx683_fail - rx683_cur."!mark_push"(0, -1, 0, $P10) + rx712_cur."!cursor_pos"(rx712_pos) + $P10 = rx712_cur."default_value"() + unless $P10, rx712_fail + rx712_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("default_value") - rx683_pos = $P10."pos"() - (rx683_rep) = rx683_cur."!mark_commit"($I695) - rxquantr694_done: -.annotate 'line', 311 + rx712_pos = $P10."pos"() + (rx712_rep) = rx712_cur."!mark_commit"($I724) + rxquantr723_done: +.annotate 'line', 323 # rx pass - rx683_cur."!cursor_pass"(rx683_pos, "parameter") - rx683_cur."!cursor_debug"("PASS ", "parameter", " at pos=", rx683_pos) - .return (rx683_cur) - rx683_fail: -.annotate 'line', 4 - (rx683_rep, rx683_pos, $I10, $P10) = rx683_cur."!mark_fail"(0) - lt rx683_pos, -1, rx683_done - eq rx683_pos, -1, rx683_fail + rx712_cur."!cursor_pass"(rx712_pos, "parameter") + rx712_cur."!cursor_debug"("PASS ", "parameter", " at pos=", rx712_pos) + .return (rx712_cur) + rx712_fail: +.annotate 'line', 4 + (rx712_rep, rx712_pos, $I10, $P10) = rx712_cur."!mark_fail"(0) + lt rx712_pos, -1, rx712_done + eq rx712_pos, -1, rx712_fail jump $I10 - rx683_done: - rx683_cur."!cursor_fail"() - rx683_cur."!cursor_debug"("FAIL ", "parameter") - .return (rx683_cur) + rx712_done: + rx712_cur."!cursor_fail"() + rx712_cur."!cursor_debug"("FAIL ", "parameter") + .return (rx712_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__parameter" :subid("162_1275511697.61926") :method +.sub "!PREFIX__parameter" :subid("171_1275600007.84296") :method .annotate 'line', 4 - new $P685, "ResizablePMCArray" - push $P685, "" - .return ($P685) + new $P714, "ResizablePMCArray" + push $P714, "" + .return ($P714) .end .namespace ["NQP";"Grammar"] -.sub "param_var" :subid("163_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "param_var" :subid("172_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx697_tgt - .local int rx697_pos - .local int rx697_off - .local int rx697_eos - .local int rx697_rep - .local pmc rx697_cur - (rx697_cur, rx697_pos, rx697_tgt) = self."!cursor_start"() - rx697_cur."!cursor_debug"("START ", "param_var") - rx697_cur."!cursor_caparray"("twigil") - .lex unicode:"$\x{a2}", rx697_cur + .local string rx726_tgt + .local int rx726_pos + .local int rx726_off + .local int rx726_eos + .local int rx726_rep + .local pmc rx726_cur + (rx726_cur, rx726_pos, rx726_tgt) = self."!cursor_start"() + rx726_cur."!cursor_debug"("START ", "param_var") + rx726_cur."!cursor_caparray"("twigil") + .lex unicode:"$\x{a2}", rx726_cur .local pmc match .lex "$/", match - length rx697_eos, rx697_tgt - gt rx697_pos, rx697_eos, rx697_done - set rx697_off, 0 - lt rx697_pos, 2, rx697_start - sub rx697_off, rx697_pos, 1 - substr rx697_tgt, rx697_tgt, rx697_off - rx697_start: + length rx726_eos, rx726_tgt + gt rx726_pos, rx726_eos, rx726_done + set rx726_off, 0 + lt rx726_pos, 2, rx726_start + sub rx726_off, rx726_pos, 1 + substr rx726_tgt, rx726_tgt, rx726_off + rx726_start: $I10 = self.'from'() - ne $I10, -1, rxscan701_done - goto rxscan701_scan - rxscan701_loop: - ($P10) = rx697_cur."from"() + ne $I10, -1, rxscan730_done + goto rxscan730_scan + rxscan730_loop: + ($P10) = rx726_cur."from"() inc $P10 - set rx697_pos, $P10 - ge rx697_pos, rx697_eos, rxscan701_done - rxscan701_scan: - set_addr $I10, rxscan701_loop - rx697_cur."!mark_push"(0, rx697_pos, $I10) - rxscan701_done: -.annotate 'line', 321 + set rx726_pos, $P10 + ge rx726_pos, rx726_eos, rxscan730_done + rxscan730_scan: + set_addr $I10, rxscan730_loop + rx726_cur."!mark_push"(0, rx726_pos, $I10) + rxscan730_done: +.annotate 'line', 333 # rx subrule "sigil" subtype=capture negate= - rx697_cur."!cursor_pos"(rx697_pos) - $P10 = rx697_cur."sigil"() - unless $P10, rx697_fail - rx697_cur."!mark_push"(0, -1, 0, $P10) + rx726_cur."!cursor_pos"(rx726_pos) + $P10 = rx726_cur."sigil"() + unless $P10, rx726_fail + rx726_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sigil") - rx697_pos = $P10."pos"() - # rx rxquantr702 ** 0..1 - set_addr $I703, rxquantr702_done - rx697_cur."!mark_push"(0, rx697_pos, $I703) - rxquantr702_loop: + rx726_pos = $P10."pos"() + # rx rxquantr731 ** 0..1 + set_addr $I732, rxquantr731_done + rx726_cur."!mark_push"(0, rx726_pos, $I732) + rxquantr731_loop: # rx subrule "twigil" subtype=capture negate= - rx697_cur."!cursor_pos"(rx697_pos) - $P10 = rx697_cur."twigil"() - unless $P10, rx697_fail - rx697_cur."!mark_push"(0, -1, 0, $P10) + rx726_cur."!cursor_pos"(rx726_pos) + $P10 = rx726_cur."twigil"() + unless $P10, rx726_fail + rx726_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("twigil") - rx697_pos = $P10."pos"() - (rx697_rep) = rx697_cur."!mark_commit"($I703) - rxquantr702_done: - alt704_0: -.annotate 'line', 322 - set_addr $I10, alt704_1 - rx697_cur."!mark_push"(0, rx697_pos, $I10) + rx726_pos = $P10."pos"() + (rx726_rep) = rx726_cur."!mark_commit"($I732) + rxquantr731_done: + alt733_0: +.annotate 'line', 334 + set_addr $I10, alt733_1 + rx726_cur."!mark_push"(0, rx726_pos, $I10) # rx subrule "ident" subtype=capture negate= - rx697_cur."!cursor_pos"(rx697_pos) - $P10 = rx697_cur."ident"() - unless $P10, rx697_fail - rx697_cur."!mark_push"(0, -1, 0, $P10) + rx726_cur."!cursor_pos"(rx726_pos) + $P10 = rx726_cur."ident"() + unless $P10, rx726_fail + rx726_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("name") - rx697_pos = $P10."pos"() - goto alt704_end - alt704_1: + rx726_pos = $P10."pos"() + goto alt733_end + alt733_1: # rx subcapture "name" - set_addr $I10, rxcap_705_fail - rx697_cur."!mark_push"(0, rx697_pos, $I10) + set_addr $I10, rxcap_734_fail + rx726_cur."!mark_push"(0, rx726_pos, $I10) # rx enumcharlist negate=0 - ge rx697_pos, rx697_eos, rx697_fail - sub $I10, rx697_pos, rx697_off - substr $S10, rx697_tgt, $I10, 1 + ge rx726_pos, rx726_eos, rx726_fail + sub $I10, rx726_pos, rx726_off + substr $S10, rx726_tgt, $I10, 1 index $I11, "/!", $S10 - lt $I11, 0, rx697_fail - inc rx697_pos - set_addr $I10, rxcap_705_fail - ($I12, $I11) = rx697_cur."!mark_peek"($I10) - rx697_cur."!cursor_pos"($I11) - ($P10) = rx697_cur."!cursor_start"() - $P10."!cursor_pass"(rx697_pos, "") - rx697_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, 0, rx726_fail + inc rx726_pos + set_addr $I10, rxcap_734_fail + ($I12, $I11) = rx726_cur."!mark_peek"($I10) + rx726_cur."!cursor_pos"($I11) + ($P10) = rx726_cur."!cursor_start"() + $P10."!cursor_pass"(rx726_pos, "") + rx726_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("name") - goto rxcap_705_done - rxcap_705_fail: - goto rx697_fail - rxcap_705_done: - alt704_end: -.annotate 'line', 320 + goto rxcap_734_done + rxcap_734_fail: + goto rx726_fail + rxcap_734_done: + alt733_end: +.annotate 'line', 332 # rx pass - rx697_cur."!cursor_pass"(rx697_pos, "param_var") - rx697_cur."!cursor_debug"("PASS ", "param_var", " at pos=", rx697_pos) - .return (rx697_cur) - rx697_fail: -.annotate 'line', 4 - (rx697_rep, rx697_pos, $I10, $P10) = rx697_cur."!mark_fail"(0) - lt rx697_pos, -1, rx697_done - eq rx697_pos, -1, rx697_fail + rx726_cur."!cursor_pass"(rx726_pos, "param_var") + rx726_cur."!cursor_debug"("PASS ", "param_var", " at pos=", rx726_pos) + .return (rx726_cur) + rx726_fail: +.annotate 'line', 4 + (rx726_rep, rx726_pos, $I10, $P10) = rx726_cur."!mark_fail"(0) + lt rx726_pos, -1, rx726_done + eq rx726_pos, -1, rx726_fail jump $I10 - rx697_done: - rx697_cur."!cursor_fail"() - rx697_cur."!cursor_debug"("FAIL ", "param_var") - .return (rx697_cur) + rx726_done: + rx726_cur."!cursor_fail"() + rx726_cur."!cursor_debug"("FAIL ", "param_var") + .return (rx726_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__param_var" :subid("164_1275511697.61926") :method +.sub "!PREFIX__param_var" :subid("173_1275600007.84296") :method .annotate 'line', 4 - $P699 = self."!PREFIX__!subrule"("sigil", "") - new $P700, "ResizablePMCArray" - push $P700, $P699 - .return ($P700) + $P728 = self."!PREFIX__!subrule"("sigil", "") + new $P729, "ResizablePMCArray" + push $P729, $P728 + .return ($P729) .end .namespace ["NQP";"Grammar"] -.sub "named_param" :subid("165_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "named_param" :subid("174_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx707_tgt - .local int rx707_pos - .local int rx707_off - .local int rx707_eos - .local int rx707_rep - .local pmc rx707_cur - (rx707_cur, rx707_pos, rx707_tgt) = self."!cursor_start"() - rx707_cur."!cursor_debug"("START ", "named_param") - .lex unicode:"$\x{a2}", rx707_cur + .local string rx736_tgt + .local int rx736_pos + .local int rx736_off + .local int rx736_eos + .local int rx736_rep + .local pmc rx736_cur + (rx736_cur, rx736_pos, rx736_tgt) = self."!cursor_start"() + rx736_cur."!cursor_debug"("START ", "named_param") + .lex unicode:"$\x{a2}", rx736_cur .local pmc match .lex "$/", match - length rx707_eos, rx707_tgt - gt rx707_pos, rx707_eos, rx707_done - set rx707_off, 0 - lt rx707_pos, 2, rx707_start - sub rx707_off, rx707_pos, 1 - substr rx707_tgt, rx707_tgt, rx707_off - rx707_start: + length rx736_eos, rx736_tgt + gt rx736_pos, rx736_eos, rx736_done + set rx736_off, 0 + lt rx736_pos, 2, rx736_start + sub rx736_off, rx736_pos, 1 + substr rx736_tgt, rx736_tgt, rx736_off + rx736_start: $I10 = self.'from'() - ne $I10, -1, rxscan711_done - goto rxscan711_scan - rxscan711_loop: - ($P10) = rx707_cur."from"() + ne $I10, -1, rxscan740_done + goto rxscan740_scan + rxscan740_loop: + ($P10) = rx736_cur."from"() inc $P10 - set rx707_pos, $P10 - ge rx707_pos, rx707_eos, rxscan711_done - rxscan711_scan: - set_addr $I10, rxscan711_loop - rx707_cur."!mark_push"(0, rx707_pos, $I10) - rxscan711_done: -.annotate 'line', 326 + set rx736_pos, $P10 + ge rx736_pos, rx736_eos, rxscan740_done + rxscan740_scan: + set_addr $I10, rxscan740_loop + rx736_cur."!mark_push"(0, rx736_pos, $I10) + rxscan740_done: +.annotate 'line', 338 # rx literal ":" - add $I11, rx707_pos, 1 - gt $I11, rx707_eos, rx707_fail - sub $I11, rx707_pos, rx707_off - substr $S10, rx707_tgt, $I11, 1 - ne $S10, ":", rx707_fail - add rx707_pos, 1 + add $I11, rx736_pos, 1 + gt $I11, rx736_eos, rx736_fail + sub $I11, rx736_pos, rx736_off + substr $S10, rx736_tgt, $I11, 1 + ne $S10, ":", rx736_fail + add rx736_pos, 1 # rx subrule "param_var" subtype=capture negate= - rx707_cur."!cursor_pos"(rx707_pos) - $P10 = rx707_cur."param_var"() - unless $P10, rx707_fail - rx707_cur."!mark_push"(0, -1, 0, $P10) + rx736_cur."!cursor_pos"(rx736_pos) + $P10 = rx736_cur."param_var"() + unless $P10, rx736_fail + rx736_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("param_var") - rx707_pos = $P10."pos"() -.annotate 'line', 325 + rx736_pos = $P10."pos"() +.annotate 'line', 337 # rx pass - rx707_cur."!cursor_pass"(rx707_pos, "named_param") - rx707_cur."!cursor_debug"("PASS ", "named_param", " at pos=", rx707_pos) - .return (rx707_cur) - rx707_fail: -.annotate 'line', 4 - (rx707_rep, rx707_pos, $I10, $P10) = rx707_cur."!mark_fail"(0) - lt rx707_pos, -1, rx707_done - eq rx707_pos, -1, rx707_fail + rx736_cur."!cursor_pass"(rx736_pos, "named_param") + rx736_cur."!cursor_debug"("PASS ", "named_param", " at pos=", rx736_pos) + .return (rx736_cur) + rx736_fail: +.annotate 'line', 4 + (rx736_rep, rx736_pos, $I10, $P10) = rx736_cur."!mark_fail"(0) + lt rx736_pos, -1, rx736_done + eq rx736_pos, -1, rx736_fail jump $I10 - rx707_done: - rx707_cur."!cursor_fail"() - rx707_cur."!cursor_debug"("FAIL ", "named_param") - .return (rx707_cur) + rx736_done: + rx736_cur."!cursor_fail"() + rx736_cur."!cursor_debug"("FAIL ", "named_param") + .return (rx736_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__named_param" :subid("166_1275511697.61926") :method +.sub "!PREFIX__named_param" :subid("175_1275600007.84296") :method .annotate 'line', 4 - $P709 = self."!PREFIX__!subrule"("param_var", ":") - new $P710, "ResizablePMCArray" - push $P710, $P709 - .return ($P710) + $P738 = self."!PREFIX__!subrule"("param_var", ":") + new $P739, "ResizablePMCArray" + push $P739, $P738 + .return ($P739) .end .namespace ["NQP";"Grammar"] -.sub "default_value" :subid("167_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "default_value" :subid("176_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx713_tgt - .local int rx713_pos - .local int rx713_off - .local int rx713_eos - .local int rx713_rep - .local pmc rx713_cur - (rx713_cur, rx713_pos, rx713_tgt) = self."!cursor_start"() - rx713_cur."!cursor_debug"("START ", "default_value") - .lex unicode:"$\x{a2}", rx713_cur + .local string rx742_tgt + .local int rx742_pos + .local int rx742_off + .local int rx742_eos + .local int rx742_rep + .local pmc rx742_cur + (rx742_cur, rx742_pos, rx742_tgt) = self."!cursor_start"() + rx742_cur."!cursor_debug"("START ", "default_value") + .lex unicode:"$\x{a2}", rx742_cur .local pmc match .lex "$/", match - length rx713_eos, rx713_tgt - gt rx713_pos, rx713_eos, rx713_done - set rx713_off, 0 - lt rx713_pos, 2, rx713_start - sub rx713_off, rx713_pos, 1 - substr rx713_tgt, rx713_tgt, rx713_off - rx713_start: + length rx742_eos, rx742_tgt + gt rx742_pos, rx742_eos, rx742_done + set rx742_off, 0 + lt rx742_pos, 2, rx742_start + sub rx742_off, rx742_pos, 1 + substr rx742_tgt, rx742_tgt, rx742_off + rx742_start: $I10 = self.'from'() - ne $I10, -1, rxscan716_done - goto rxscan716_scan - rxscan716_loop: - ($P10) = rx713_cur."from"() + ne $I10, -1, rxscan745_done + goto rxscan745_scan + rxscan745_loop: + ($P10) = rx742_cur."from"() inc $P10 - set rx713_pos, $P10 - ge rx713_pos, rx713_eos, rxscan716_done - rxscan716_scan: - set_addr $I10, rxscan716_loop - rx713_cur."!mark_push"(0, rx713_pos, $I10) - rxscan716_done: -.annotate 'line', 329 + set rx742_pos, $P10 + ge rx742_pos, rx742_eos, rxscan745_done + rxscan745_scan: + set_addr $I10, rxscan745_loop + rx742_cur."!mark_push"(0, rx742_pos, $I10) + rxscan745_done: +.annotate 'line', 341 # rx subrule "ws" subtype=method negate= - rx713_cur."!cursor_pos"(rx713_pos) - $P10 = rx713_cur."ws"() - unless $P10, rx713_fail - rx713_pos = $P10."pos"() + rx742_cur."!cursor_pos"(rx742_pos) + $P10 = rx742_cur."ws"() + unless $P10, rx742_fail + rx742_pos = $P10."pos"() # rx literal "=" - add $I11, rx713_pos, 1 - gt $I11, rx713_eos, rx713_fail - sub $I11, rx713_pos, rx713_off - substr $S10, rx713_tgt, $I11, 1 - ne $S10, "=", rx713_fail - add rx713_pos, 1 + add $I11, rx742_pos, 1 + gt $I11, rx742_eos, rx742_fail + sub $I11, rx742_pos, rx742_off + substr $S10, rx742_tgt, $I11, 1 + ne $S10, "=", rx742_fail + add rx742_pos, 1 # rx subrule "ws" subtype=method negate= - rx713_cur."!cursor_pos"(rx713_pos) - $P10 = rx713_cur."ws"() - unless $P10, rx713_fail - rx713_pos = $P10."pos"() + rx742_cur."!cursor_pos"(rx742_pos) + $P10 = rx742_cur."ws"() + unless $P10, rx742_fail + rx742_pos = $P10."pos"() # rx subrule "EXPR" subtype=capture negate= - rx713_cur."!cursor_pos"(rx713_pos) - $P10 = rx713_cur."EXPR"("i=") - unless $P10, rx713_fail - rx713_cur."!mark_push"(0, -1, 0, $P10) + rx742_cur."!cursor_pos"(rx742_pos) + $P10 = rx742_cur."EXPR"("i=") + unless $P10, rx742_fail + rx742_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("EXPR") - rx713_pos = $P10."pos"() + rx742_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx713_cur."!cursor_pos"(rx713_pos) - $P10 = rx713_cur."ws"() - unless $P10, rx713_fail - rx713_pos = $P10."pos"() + rx742_cur."!cursor_pos"(rx742_pos) + $P10 = rx742_cur."ws"() + unless $P10, rx742_fail + rx742_pos = $P10."pos"() # rx pass - rx713_cur."!cursor_pass"(rx713_pos, "default_value") - rx713_cur."!cursor_debug"("PASS ", "default_value", " at pos=", rx713_pos) - .return (rx713_cur) - rx713_fail: -.annotate 'line', 4 - (rx713_rep, rx713_pos, $I10, $P10) = rx713_cur."!mark_fail"(0) - lt rx713_pos, -1, rx713_done - eq rx713_pos, -1, rx713_fail + rx742_cur."!cursor_pass"(rx742_pos, "default_value") + rx742_cur."!cursor_debug"("PASS ", "default_value", " at pos=", rx742_pos) + .return (rx742_cur) + rx742_fail: +.annotate 'line', 4 + (rx742_rep, rx742_pos, $I10, $P10) = rx742_cur."!mark_fail"(0) + lt rx742_pos, -1, rx742_done + eq rx742_pos, -1, rx742_fail jump $I10 - rx713_done: - rx713_cur."!cursor_fail"() - rx713_cur."!cursor_debug"("FAIL ", "default_value") - .return (rx713_cur) + rx742_done: + rx742_cur."!cursor_fail"() + rx742_cur."!cursor_debug"("FAIL ", "default_value") + .return (rx742_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__default_value" :subid("168_1275511697.61926") :method +.sub "!PREFIX__default_value" :subid("177_1275600007.84296") :method .annotate 'line', 4 - new $P715, "ResizablePMCArray" - push $P715, "" - .return ($P715) + new $P744, "ResizablePMCArray" + push $P744, "" + .return ($P744) .end .namespace ["NQP";"Grammar"] -.sub "regex_declarator" :subid("169_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "regex_declarator" :subid("178_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx721_tgt - .local int rx721_pos - .local int rx721_off - .local int rx721_eos - .local int rx721_rep - .local pmc rx721_cur - (rx721_cur, rx721_pos, rx721_tgt) = self."!cursor_start"() - rx721_cur."!cursor_debug"("START ", "regex_declarator") - rx721_cur."!cursor_caparray"("signature") - .lex unicode:"$\x{a2}", rx721_cur + .local string rx750_tgt + .local int rx750_pos + .local int rx750_off + .local int rx750_eos + .local int rx750_rep + .local pmc rx750_cur + (rx750_cur, rx750_pos, rx750_tgt) = self."!cursor_start"() + rx750_cur."!cursor_debug"("START ", "regex_declarator") + rx750_cur."!cursor_caparray"("signature") + .lex unicode:"$\x{a2}", rx750_cur .local pmc match .lex "$/", match - length rx721_eos, rx721_tgt - gt rx721_pos, rx721_eos, rx721_done - set rx721_off, 0 - lt rx721_pos, 2, rx721_start - sub rx721_off, rx721_pos, 1 - substr rx721_tgt, rx721_tgt, rx721_off - rx721_start: + length rx750_eos, rx750_tgt + gt rx750_pos, rx750_eos, rx750_done + set rx750_off, 0 + lt rx750_pos, 2, rx750_start + sub rx750_off, rx750_pos, 1 + substr rx750_tgt, rx750_tgt, rx750_off + rx750_start: $I10 = self.'from'() - ne $I10, -1, rxscan724_done - goto rxscan724_scan - rxscan724_loop: - ($P10) = rx721_cur."from"() + ne $I10, -1, rxscan753_done + goto rxscan753_scan + rxscan753_loop: + ($P10) = rx750_cur."from"() inc $P10 - set rx721_pos, $P10 - ge rx721_pos, rx721_eos, rxscan724_done - rxscan724_scan: - set_addr $I10, rxscan724_loop - rx721_cur."!mark_push"(0, rx721_pos, $I10) - rxscan724_done: -.annotate 'line', 331 + set rx750_pos, $P10 + ge rx750_pos, rx750_eos, rxscan753_done + rxscan753_scan: + set_addr $I10, rxscan753_loop + rx750_cur."!mark_push"(0, rx750_pos, $I10) + rxscan753_done: +.annotate 'line', 343 # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() - alt726_0: -.annotate 'line', 332 - set_addr $I10, alt726_1 - rx721_cur."!mark_push"(0, rx721_pos, $I10) -.annotate 'line', 333 + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() + alt755_0: +.annotate 'line', 344 + set_addr $I10, alt755_1 + rx750_cur."!mark_push"(0, rx750_pos, $I10) +.annotate 'line', 345 # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() # rx subcapture "proto" - set_addr $I10, rxcap_728_fail - rx721_cur."!mark_push"(0, rx721_pos, $I10) + set_addr $I10, rxcap_757_fail + rx750_cur."!mark_push"(0, rx750_pos, $I10) # rx literal "proto" - add $I11, rx721_pos, 5 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 5 - ne $S10, "proto", rx721_fail - add rx721_pos, 5 - set_addr $I10, rxcap_728_fail - ($I12, $I11) = rx721_cur."!mark_peek"($I10) - rx721_cur."!cursor_pos"($I11) - ($P10) = rx721_cur."!cursor_start"() - $P10."!cursor_pass"(rx721_pos, "") - rx721_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx750_pos, 5 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 5 + ne $S10, "proto", rx750_fail + add rx750_pos, 5 + set_addr $I10, rxcap_757_fail + ($I12, $I11) = rx750_cur."!mark_peek"($I10) + rx750_cur."!cursor_pos"($I11) + ($P10) = rx750_cur."!cursor_start"() + $P10."!cursor_pass"(rx750_pos, "") + rx750_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("proto") - goto rxcap_728_done - rxcap_728_fail: - goto rx721_fail - rxcap_728_done: + goto rxcap_757_done + rxcap_757_fail: + goto rx750_fail + rxcap_757_done: # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() - alt730_0: - set_addr $I10, alt730_1 - rx721_cur."!mark_push"(0, rx721_pos, $I10) + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() + alt759_0: + set_addr $I10, alt759_1 + rx750_cur."!mark_push"(0, rx750_pos, $I10) # rx literal "regex" - add $I11, rx721_pos, 5 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 5 - ne $S10, "regex", rx721_fail - add rx721_pos, 5 - goto alt730_end - alt730_1: - set_addr $I10, alt730_2 - rx721_cur."!mark_push"(0, rx721_pos, $I10) + add $I11, rx750_pos, 5 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 5 + ne $S10, "regex", rx750_fail + add rx750_pos, 5 + goto alt759_end + alt759_1: + set_addr $I10, alt759_2 + rx750_cur."!mark_push"(0, rx750_pos, $I10) # rx literal "token" - add $I11, rx721_pos, 5 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 5 - ne $S10, "token", rx721_fail - add rx721_pos, 5 - goto alt730_end - alt730_2: + add $I11, rx750_pos, 5 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 5 + ne $S10, "token", rx750_fail + add rx750_pos, 5 + goto alt759_end + alt759_2: # rx literal "rule" - add $I11, rx721_pos, 4 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 4 - ne $S10, "rule", rx721_fail - add rx721_pos, 4 - alt730_end: + add $I11, rx750_pos, 4 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 4 + ne $S10, "rule", rx750_fail + add rx750_pos, 4 + alt759_end: # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() -.annotate 'line', 334 + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() +.annotate 'line', 346 # rx subrule "deflongname" subtype=capture negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."deflongname"() - unless $P10, rx721_fail - rx721_cur."!mark_push"(0, -1, 0, $P10) + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."deflongname"() + unless $P10, rx750_fail + rx750_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("deflongname") - rx721_pos = $P10."pos"() + rx750_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() - alt733_0: -.annotate 'line', 335 - set_addr $I10, alt733_1 - rx721_cur."!mark_push"(0, rx721_pos, $I10) -.annotate 'line', 336 + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() + alt762_0: +.annotate 'line', 347 + set_addr $I10, alt762_1 + rx750_cur."!mark_push"(0, rx750_pos, $I10) +.annotate 'line', 348 # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() # rx literal "{" - add $I11, rx721_pos, 1 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 1 - ne $S10, "{", rx721_fail - add rx721_pos, 1 + add $I11, rx750_pos, 1 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 1 + ne $S10, "{", rx750_fail + add rx750_pos, 1 # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() # rx literal "<...>" - add $I11, rx721_pos, 5 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 5 - ne $S10, "<...>", rx721_fail - add rx721_pos, 5 + add $I11, rx750_pos, 5 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 5 + ne $S10, "<...>", rx750_fail + add rx750_pos, 5 # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() # rx literal "}" - add $I11, rx721_pos, 1 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 1 - ne $S10, "}", rx721_fail - add rx721_pos, 1 + add $I11, rx750_pos, 1 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 1 + ne $S10, "}", rx750_fail + add rx750_pos, 1 # rx subrule "ENDSTMT" subtype=zerowidth negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ENDSTMT"() - unless $P10, rx721_fail + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ENDSTMT"() + unless $P10, rx750_fail # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() - goto alt733_end - alt733_1: -.annotate 'line', 337 + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() + goto alt762_end + alt762_1: +.annotate 'line', 349 # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() # rx subrule "panic" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."panic"("Proto regex body must be <...>") - unless $P10, rx721_fail - rx721_pos = $P10."pos"() + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."panic"("Proto regex body must be <...>") + unless $P10, rx750_fail + rx750_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() - alt733_end: -.annotate 'line', 338 + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() + alt762_end: +.annotate 'line', 350 # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() -.annotate 'line', 333 - goto alt726_end - alt726_1: -.annotate 'line', 339 + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() +.annotate 'line', 345 + goto alt755_end + alt755_1: +.annotate 'line', 351 # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() # rx subcapture "sym" - set_addr $I10, rxcap_743_fail - rx721_cur."!mark_push"(0, rx721_pos, $I10) - alt742_0: - set_addr $I10, alt742_1 - rx721_cur."!mark_push"(0, rx721_pos, $I10) + set_addr $I10, rxcap_772_fail + rx750_cur."!mark_push"(0, rx750_pos, $I10) + alt771_0: + set_addr $I10, alt771_1 + rx750_cur."!mark_push"(0, rx750_pos, $I10) # rx literal "regex" - add $I11, rx721_pos, 5 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 5 - ne $S10, "regex", rx721_fail - add rx721_pos, 5 - goto alt742_end - alt742_1: - set_addr $I10, alt742_2 - rx721_cur."!mark_push"(0, rx721_pos, $I10) + add $I11, rx750_pos, 5 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 5 + ne $S10, "regex", rx750_fail + add rx750_pos, 5 + goto alt771_end + alt771_1: + set_addr $I10, alt771_2 + rx750_cur."!mark_push"(0, rx750_pos, $I10) # rx literal "token" - add $I11, rx721_pos, 5 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 5 - ne $S10, "token", rx721_fail - add rx721_pos, 5 - goto alt742_end - alt742_2: + add $I11, rx750_pos, 5 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 5 + ne $S10, "token", rx750_fail + add rx750_pos, 5 + goto alt771_end + alt771_2: # rx literal "rule" - add $I11, rx721_pos, 4 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 4 - ne $S10, "rule", rx721_fail - add rx721_pos, 4 - alt742_end: - set_addr $I10, rxcap_743_fail - ($I12, $I11) = rx721_cur."!mark_peek"($I10) - rx721_cur."!cursor_pos"($I11) - ($P10) = rx721_cur."!cursor_start"() - $P10."!cursor_pass"(rx721_pos, "") - rx721_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx750_pos, 4 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 4 + ne $S10, "rule", rx750_fail + add rx750_pos, 4 + alt771_end: + set_addr $I10, rxcap_772_fail + ($I12, $I11) = rx750_cur."!mark_peek"($I10) + rx750_cur."!cursor_pos"($I11) + ($P10) = rx750_cur."!cursor_start"() + $P10."!cursor_pass"(rx750_pos, "") + rx750_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_743_done - rxcap_743_fail: - goto rx721_fail - rxcap_743_done: + goto rxcap_772_done + rxcap_772_fail: + goto rx750_fail + rxcap_772_done: # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() -.annotate 'line', 340 + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() +.annotate 'line', 352 # rx subrule "deflongname" subtype=capture negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."deflongname"() - unless $P10, rx721_fail - rx721_cur."!mark_push"(0, -1, 0, $P10) + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."deflongname"() + unless $P10, rx750_fail + rx750_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("deflongname") - rx721_pos = $P10."pos"() + rx750_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() -.annotate 'line', 341 + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() +.annotate 'line', 353 # rx subrule "newpad" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."newpad"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."newpad"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() -.annotate 'line', 342 - # rx rxquantr747 ** 0..1 - set_addr $I752, rxquantr747_done - rx721_cur."!mark_push"(0, rx721_pos, $I752) - rxquantr747_loop: + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() +.annotate 'line', 354 + # rx rxquantr776 ** 0..1 + set_addr $I781, rxquantr776_done + rx750_cur."!mark_push"(0, rx750_pos, $I781) + rxquantr776_loop: # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() # rx literal "(" - add $I11, rx721_pos, 1 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 1 - ne $S10, "(", rx721_fail - add rx721_pos, 1 + add $I11, rx750_pos, 1 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 1 + ne $S10, "(", rx750_fail + add rx750_pos, 1 # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() # rx subrule "signature" subtype=capture negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."signature"() - unless $P10, rx721_fail - rx721_cur."!mark_push"(0, -1, 0, $P10) + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."signature"() + unless $P10, rx750_fail + rx750_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("signature") - rx721_pos = $P10."pos"() + rx750_pos = $P10."pos"() # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() # rx literal ")" - add $I11, rx721_pos, 1 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 1 - ne $S10, ")", rx721_fail - add rx721_pos, 1 + add $I11, rx750_pos, 1 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 1 + ne $S10, ")", rx750_fail + add rx750_pos, 1 # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() - (rx721_rep) = rx721_cur."!mark_commit"($I752) - rxquantr747_done: + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() + (rx750_rep) = rx750_cur."!mark_commit"($I781) + rxquantr776_done: # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() -.annotate 'line', 343 + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() +.annotate 'line', 355 # rx reduce name="regex_declarator" key="open" - rx721_cur."!cursor_pos"(rx721_pos) - rx721_cur."!reduce"("regex_declarator", "open") + rx750_cur."!cursor_pos"(rx750_pos) + rx750_cur."!reduce"("regex_declarator", "open") # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() -.annotate 'line', 344 + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() +.annotate 'line', 356 # rx literal "{" - add $I11, rx721_pos, 1 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 1 - ne $S10, "{", rx721_fail - add rx721_pos, 1 + add $I11, rx750_pos, 1 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 1 + ne $S10, "{", rx750_fail + add rx750_pos, 1 # rx subrule "LANG" subtype=capture negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."LANG"("Regex", "nibbler") - unless $P10, rx721_fail - rx721_cur."!mark_push"(0, -1, 0, $P10) + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."LANG"("Regex", "nibbler") + unless $P10, rx750_fail + rx750_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("p6regex") - rx721_pos = $P10."pos"() + rx750_pos = $P10."pos"() # rx literal "}" - add $I11, rx721_pos, 1 - gt $I11, rx721_eos, rx721_fail - sub $I11, rx721_pos, rx721_off - substr $S10, rx721_tgt, $I11, 1 - ne $S10, "}", rx721_fail - add rx721_pos, 1 + add $I11, rx750_pos, 1 + gt $I11, rx750_eos, rx750_fail + sub $I11, rx750_pos, rx750_off + substr $S10, rx750_tgt, $I11, 1 + ne $S10, "}", rx750_fail + add rx750_pos, 1 # rx subrule "ENDSTMT" subtype=zerowidth negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ENDSTMT"() - unless $P10, rx721_fail + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ENDSTMT"() + unless $P10, rx750_fail # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() - alt726_end: -.annotate 'line', 345 + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() + alt755_end: +.annotate 'line', 357 # rx subrule "ws" subtype=method negate= - rx721_cur."!cursor_pos"(rx721_pos) - $P10 = rx721_cur."ws"() - unless $P10, rx721_fail - rx721_pos = $P10."pos"() -.annotate 'line', 331 + rx750_cur."!cursor_pos"(rx750_pos) + $P10 = rx750_cur."ws"() + unless $P10, rx750_fail + rx750_pos = $P10."pos"() +.annotate 'line', 343 # rx pass - rx721_cur."!cursor_pass"(rx721_pos, "regex_declarator") - rx721_cur."!cursor_debug"("PASS ", "regex_declarator", " at pos=", rx721_pos) - .return (rx721_cur) - rx721_fail: -.annotate 'line', 4 - (rx721_rep, rx721_pos, $I10, $P10) = rx721_cur."!mark_fail"(0) - lt rx721_pos, -1, rx721_done - eq rx721_pos, -1, rx721_fail + rx750_cur."!cursor_pass"(rx750_pos, "regex_declarator") + rx750_cur."!cursor_debug"("PASS ", "regex_declarator", " at pos=", rx750_pos) + .return (rx750_cur) + rx750_fail: +.annotate 'line', 4 + (rx750_rep, rx750_pos, $I10, $P10) = rx750_cur."!mark_fail"(0) + lt rx750_pos, -1, rx750_done + eq rx750_pos, -1, rx750_fail jump $I10 - rx721_done: - rx721_cur."!cursor_fail"() - rx721_cur."!cursor_debug"("FAIL ", "regex_declarator") - .return (rx721_cur) + rx750_done: + rx750_cur."!cursor_fail"() + rx750_cur."!cursor_debug"("FAIL ", "regex_declarator") + .return (rx750_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__regex_declarator" :subid("170_1275511697.61926") :method +.sub "!PREFIX__regex_declarator" :subid("179_1275600007.84296") :method .annotate 'line', 4 - new $P723, "ResizablePMCArray" - push $P723, "" - .return ($P723) + new $P752, "ResizablePMCArray" + push $P752, "" + .return ($P752) .end .namespace ["NQP";"Grammar"] -.sub "dotty" :subid("171_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "dotty" :subid("180_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx758_tgt - .local int rx758_pos - .local int rx758_off - .local int rx758_eos - .local int rx758_rep - .local pmc rx758_cur - (rx758_cur, rx758_pos, rx758_tgt) = self."!cursor_start"() - rx758_cur."!cursor_debug"("START ", "dotty") - rx758_cur."!cursor_caparray"("args") - .lex unicode:"$\x{a2}", rx758_cur + .local string rx787_tgt + .local int rx787_pos + .local int rx787_off + .local int rx787_eos + .local int rx787_rep + .local pmc rx787_cur + (rx787_cur, rx787_pos, rx787_tgt) = self."!cursor_start"() + rx787_cur."!cursor_debug"("START ", "dotty") + rx787_cur."!cursor_caparray"("args") + .lex unicode:"$\x{a2}", rx787_cur .local pmc match .lex "$/", match - length rx758_eos, rx758_tgt - gt rx758_pos, rx758_eos, rx758_done - set rx758_off, 0 - lt rx758_pos, 2, rx758_start - sub rx758_off, rx758_pos, 1 - substr rx758_tgt, rx758_tgt, rx758_off - rx758_start: + length rx787_eos, rx787_tgt + gt rx787_pos, rx787_eos, rx787_done + set rx787_off, 0 + lt rx787_pos, 2, rx787_start + sub rx787_off, rx787_pos, 1 + substr rx787_tgt, rx787_tgt, rx787_off + rx787_start: $I10 = self.'from'() - ne $I10, -1, rxscan762_done - goto rxscan762_scan - rxscan762_loop: - ($P10) = rx758_cur."from"() + ne $I10, -1, rxscan791_done + goto rxscan791_scan + rxscan791_loop: + ($P10) = rx787_cur."from"() inc $P10 - set rx758_pos, $P10 - ge rx758_pos, rx758_eos, rxscan762_done - rxscan762_scan: - set_addr $I10, rxscan762_loop - rx758_cur."!mark_push"(0, rx758_pos, $I10) - rxscan762_done: -.annotate 'line', 349 + set rx787_pos, $P10 + ge rx787_pos, rx787_eos, rxscan791_done + rxscan791_scan: + set_addr $I10, rxscan791_loop + rx787_cur."!mark_push"(0, rx787_pos, $I10) + rxscan791_done: +.annotate 'line', 361 # rx literal "." - add $I11, rx758_pos, 1 - gt $I11, rx758_eos, rx758_fail - sub $I11, rx758_pos, rx758_off - substr $S10, rx758_tgt, $I11, 1 - ne $S10, ".", rx758_fail - add rx758_pos, 1 - alt763_0: -.annotate 'line', 350 - set_addr $I10, alt763_1 - rx758_cur."!mark_push"(0, rx758_pos, $I10) + add $I11, rx787_pos, 1 + gt $I11, rx787_eos, rx787_fail + sub $I11, rx787_pos, rx787_off + substr $S10, rx787_tgt, $I11, 1 + ne $S10, ".", rx787_fail + add rx787_pos, 1 + alt792_0: +.annotate 'line', 362 + set_addr $I10, alt792_1 + rx787_cur."!mark_push"(0, rx787_pos, $I10) # rx subrule "identifier" subtype=capture negate= - rx758_cur."!cursor_pos"(rx758_pos) - $P10 = rx758_cur."identifier"() - unless $P10, rx758_fail - rx758_cur."!mark_push"(0, -1, 0, $P10) + rx787_cur."!cursor_pos"(rx787_pos) + $P10 = rx787_cur."identifier"() + unless $P10, rx787_fail + rx787_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("longname=identifier") - rx758_pos = $P10."pos"() - goto alt763_end - alt763_1: -.annotate 'line', 351 + rx787_pos = $P10."pos"() + goto alt792_end + alt792_1: +.annotate 'line', 363 # rx enumcharlist negate=0 zerowidth - ge rx758_pos, rx758_eos, rx758_fail - sub $I10, rx758_pos, rx758_off - substr $S10, rx758_tgt, $I10, 1 + ge rx787_pos, rx787_eos, rx787_fail + sub $I10, rx787_pos, rx787_off + substr $S10, rx787_tgt, $I10, 1 index $I11, "'\"", $S10 - lt $I11, 0, rx758_fail + lt $I11, 0, rx787_fail # rx subrule "quote" subtype=capture negate= - rx758_cur."!cursor_pos"(rx758_pos) - $P10 = rx758_cur."quote"() - unless $P10, rx758_fail - rx758_cur."!mark_push"(0, -1, 0, $P10) + rx787_cur."!cursor_pos"(rx787_pos) + $P10 = rx787_cur."quote"() + unless $P10, rx787_fail + rx787_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quote") - rx758_pos = $P10."pos"() - alt764_0: -.annotate 'line', 352 - set_addr $I10, alt764_1 - rx758_cur."!mark_push"(0, rx758_pos, $I10) + rx787_pos = $P10."pos"() + alt793_0: +.annotate 'line', 364 + set_addr $I10, alt793_1 + rx787_cur."!mark_push"(0, rx787_pos, $I10) # rx enumcharlist negate=0 zerowidth - ge rx758_pos, rx758_eos, rx758_fail - sub $I10, rx758_pos, rx758_off - substr $S10, rx758_tgt, $I10, 1 + ge rx787_pos, rx787_eos, rx787_fail + sub $I10, rx787_pos, rx787_off + substr $S10, rx787_tgt, $I10, 1 index $I11, "(", $S10 - lt $I11, 0, rx758_fail - goto alt764_end - alt764_1: + lt $I11, 0, rx787_fail + goto alt793_end + alt793_1: # rx subrule "panic" subtype=method negate= - rx758_cur."!cursor_pos"(rx758_pos) - $P10 = rx758_cur."panic"("Quoted method name requires parenthesized arguments") - unless $P10, rx758_fail - rx758_pos = $P10."pos"() - alt764_end: - alt763_end: -.annotate 'line', 358 - # rx rxquantr765 ** 0..1 - set_addr $I767, rxquantr765_done - rx758_cur."!mark_push"(0, rx758_pos, $I767) - rxquantr765_loop: - alt766_0: -.annotate 'line', 355 - set_addr $I10, alt766_1 - rx758_cur."!mark_push"(0, rx758_pos, $I10) -.annotate 'line', 356 + rx787_cur."!cursor_pos"(rx787_pos) + $P10 = rx787_cur."panic"("Quoted method name requires parenthesized arguments") + unless $P10, rx787_fail + rx787_pos = $P10."pos"() + alt793_end: + alt792_end: +.annotate 'line', 370 + # rx rxquantr794 ** 0..1 + set_addr $I796, rxquantr794_done + rx787_cur."!mark_push"(0, rx787_pos, $I796) + rxquantr794_loop: + alt795_0: +.annotate 'line', 367 + set_addr $I10, alt795_1 + rx787_cur."!mark_push"(0, rx787_pos, $I10) +.annotate 'line', 368 # rx enumcharlist negate=0 zerowidth - ge rx758_pos, rx758_eos, rx758_fail - sub $I10, rx758_pos, rx758_off - substr $S10, rx758_tgt, $I10, 1 + ge rx787_pos, rx787_eos, rx787_fail + sub $I10, rx787_pos, rx787_off + substr $S10, rx787_tgt, $I10, 1 index $I11, "(", $S10 - lt $I11, 0, rx758_fail + lt $I11, 0, rx787_fail # rx subrule "args" subtype=capture negate= - rx758_cur."!cursor_pos"(rx758_pos) - $P10 = rx758_cur."args"() - unless $P10, rx758_fail - rx758_cur."!mark_push"(0, -1, 0, $P10) + rx787_cur."!cursor_pos"(rx787_pos) + $P10 = rx787_cur."args"() + unless $P10, rx787_fail + rx787_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("args") - rx758_pos = $P10."pos"() - goto alt766_end - alt766_1: -.annotate 'line', 357 + rx787_pos = $P10."pos"() + goto alt795_end + alt795_1: +.annotate 'line', 369 # rx literal ":" - add $I11, rx758_pos, 1 - gt $I11, rx758_eos, rx758_fail - sub $I11, rx758_pos, rx758_off - substr $S10, rx758_tgt, $I11, 1 - ne $S10, ":", rx758_fail - add rx758_pos, 1 + add $I11, rx787_pos, 1 + gt $I11, rx787_eos, rx787_fail + sub $I11, rx787_pos, rx787_off + substr $S10, rx787_tgt, $I11, 1 + ne $S10, ":", rx787_fail + add rx787_pos, 1 # rx charclass s - ge rx758_pos, rx758_eos, rx758_fail - sub $I10, rx758_pos, rx758_off - is_cclass $I11, 32, rx758_tgt, $I10 - unless $I11, rx758_fail - inc rx758_pos + ge rx787_pos, rx787_eos, rx787_fail + sub $I10, rx787_pos, rx787_off + is_cclass $I11, 32, rx787_tgt, $I10 + unless $I11, rx787_fail + inc rx787_pos # rx subrule "arglist" subtype=capture negate= - rx758_cur."!cursor_pos"(rx758_pos) - $P10 = rx758_cur."arglist"() - unless $P10, rx758_fail - rx758_cur."!mark_push"(0, -1, 0, $P10) + rx787_cur."!cursor_pos"(rx787_pos) + $P10 = rx787_cur."arglist"() + unless $P10, rx787_fail + rx787_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("args") - rx758_pos = $P10."pos"() - alt766_end: -.annotate 'line', 358 - (rx758_rep) = rx758_cur."!mark_commit"($I767) - rxquantr765_done: -.annotate 'line', 348 + rx787_pos = $P10."pos"() + alt795_end: +.annotate 'line', 370 + (rx787_rep) = rx787_cur."!mark_commit"($I796) + rxquantr794_done: +.annotate 'line', 360 # rx pass - rx758_cur."!cursor_pass"(rx758_pos, "dotty") - rx758_cur."!cursor_debug"("PASS ", "dotty", " at pos=", rx758_pos) - .return (rx758_cur) - rx758_fail: -.annotate 'line', 4 - (rx758_rep, rx758_pos, $I10, $P10) = rx758_cur."!mark_fail"(0) - lt rx758_pos, -1, rx758_done - eq rx758_pos, -1, rx758_fail + rx787_cur."!cursor_pass"(rx787_pos, "dotty") + rx787_cur."!cursor_debug"("PASS ", "dotty", " at pos=", rx787_pos) + .return (rx787_cur) + rx787_fail: +.annotate 'line', 4 + (rx787_rep, rx787_pos, $I10, $P10) = rx787_cur."!mark_fail"(0) + lt rx787_pos, -1, rx787_done + eq rx787_pos, -1, rx787_fail jump $I10 - rx758_done: - rx758_cur."!cursor_fail"() - rx758_cur."!cursor_debug"("FAIL ", "dotty") - .return (rx758_cur) + rx787_done: + rx787_cur."!cursor_fail"() + rx787_cur."!cursor_debug"("FAIL ", "dotty") + .return (rx787_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__dotty" :subid("172_1275511697.61926") :method +.sub "!PREFIX__dotty" :subid("181_1275600007.84296") :method .annotate 'line', 4 - $P760 = self."!PREFIX__!subrule"("longname=identifier", ".") - new $P761, "ResizablePMCArray" - push $P761, "'" - push $P761, "\"" - push $P761, $P760 - .return ($P761) + $P789 = self."!PREFIX__!subrule"("longname=identifier", ".") + new $P790, "ResizablePMCArray" + push $P790, "'" + push $P790, "\"" + push $P790, $P789 + .return ($P790) .end .namespace ["NQP";"Grammar"] -.sub "term" :subid("173_1275511697.61926") :method -.annotate 'line', 362 - $P769 = self."!protoregex"("term") - .return ($P769) +.sub "term" :subid("182_1275600007.84296") :method +.annotate 'line', 374 + $P798 = self."!protoregex"("term") + .return ($P798) .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term" :subid("174_1275511697.61926") :method -.annotate 'line', 362 - $P771 = self."!PREFIX__!protoregex"("term") - .return ($P771) +.sub "!PREFIX__term" :subid("183_1275600007.84296") :method +.annotate 'line', 374 + $P800 = self."!PREFIX__!protoregex"("term") + .return ($P800) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("175_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("184_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx773_tgt - .local int rx773_pos - .local int rx773_off - .local int rx773_eos - .local int rx773_rep - .local pmc rx773_cur - (rx773_cur, rx773_pos, rx773_tgt) = self."!cursor_start"() - rx773_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx773_cur + .local string rx802_tgt + .local int rx802_pos + .local int rx802_off + .local int rx802_eos + .local int rx802_rep + .local pmc rx802_cur + (rx802_cur, rx802_pos, rx802_tgt) = self."!cursor_start"() + rx802_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx802_cur .local pmc match .lex "$/", match - length rx773_eos, rx773_tgt - gt rx773_pos, rx773_eos, rx773_done - set rx773_off, 0 - lt rx773_pos, 2, rx773_start - sub rx773_off, rx773_pos, 1 - substr rx773_tgt, rx773_tgt, rx773_off - rx773_start: + length rx802_eos, rx802_tgt + gt rx802_pos, rx802_eos, rx802_done + set rx802_off, 0 + lt rx802_pos, 2, rx802_start + sub rx802_off, rx802_pos, 1 + substr rx802_tgt, rx802_tgt, rx802_off + rx802_start: $I10 = self.'from'() - ne $I10, -1, rxscan776_done - goto rxscan776_scan - rxscan776_loop: - ($P10) = rx773_cur."from"() + ne $I10, -1, rxscan805_done + goto rxscan805_scan + rxscan805_loop: + ($P10) = rx802_cur."from"() inc $P10 - set rx773_pos, $P10 - ge rx773_pos, rx773_eos, rxscan776_done - rxscan776_scan: - set_addr $I10, rxscan776_loop - rx773_cur."!mark_push"(0, rx773_pos, $I10) - rxscan776_done: -.annotate 'line', 364 + set rx802_pos, $P10 + ge rx802_pos, rx802_eos, rxscan805_done + rxscan805_scan: + set_addr $I10, rxscan805_loop + rx802_cur."!mark_push"(0, rx802_pos, $I10) + rxscan805_done: +.annotate 'line', 376 # rx subcapture "sym" - set_addr $I10, rxcap_777_fail - rx773_cur."!mark_push"(0, rx773_pos, $I10) + set_addr $I10, rxcap_806_fail + rx802_cur."!mark_push"(0, rx802_pos, $I10) # rx literal "self" - add $I11, rx773_pos, 4 - gt $I11, rx773_eos, rx773_fail - sub $I11, rx773_pos, rx773_off - substr $S10, rx773_tgt, $I11, 4 - ne $S10, "self", rx773_fail - add rx773_pos, 4 - set_addr $I10, rxcap_777_fail - ($I12, $I11) = rx773_cur."!mark_peek"($I10) - rx773_cur."!cursor_pos"($I11) - ($P10) = rx773_cur."!cursor_start"() - $P10."!cursor_pass"(rx773_pos, "") - rx773_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx802_pos, 4 + gt $I11, rx802_eos, rx802_fail + sub $I11, rx802_pos, rx802_off + substr $S10, rx802_tgt, $I11, 4 + ne $S10, "self", rx802_fail + add rx802_pos, 4 + set_addr $I10, rxcap_806_fail + ($I12, $I11) = rx802_cur."!mark_peek"($I10) + rx802_cur."!cursor_pos"($I11) + ($P10) = rx802_cur."!cursor_start"() + $P10."!cursor_pass"(rx802_pos, "") + rx802_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_777_done - rxcap_777_fail: - goto rx773_fail - rxcap_777_done: + goto rxcap_806_done + rxcap_806_fail: + goto rx802_fail + rxcap_806_done: # rxanchor rwb - le rx773_pos, 0, rx773_fail - sub $I10, rx773_pos, rx773_off - is_cclass $I11, 8192, rx773_tgt, $I10 - if $I11, rx773_fail + le rx802_pos, 0, rx802_fail + sub $I10, rx802_pos, rx802_off + is_cclass $I11, 8192, rx802_tgt, $I10 + if $I11, rx802_fail dec $I10 - is_cclass $I11, 8192, rx773_tgt, $I10 - unless $I11, rx773_fail + is_cclass $I11, 8192, rx802_tgt, $I10 + unless $I11, rx802_fail # rx pass - rx773_cur."!cursor_pass"(rx773_pos, "term:sym") - rx773_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx773_pos) - .return (rx773_cur) - rx773_fail: -.annotate 'line', 4 - (rx773_rep, rx773_pos, $I10, $P10) = rx773_cur."!mark_fail"(0) - lt rx773_pos, -1, rx773_done - eq rx773_pos, -1, rx773_fail + rx802_cur."!cursor_pass"(rx802_pos, "term:sym") + rx802_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx802_pos) + .return (rx802_cur) + rx802_fail: +.annotate 'line', 4 + (rx802_rep, rx802_pos, $I10, $P10) = rx802_cur."!mark_fail"(0) + lt rx802_pos, -1, rx802_done + eq rx802_pos, -1, rx802_fail jump $I10 - rx773_done: - rx773_cur."!cursor_fail"() - rx773_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx773_cur) + rx802_done: + rx802_cur."!cursor_fail"() + rx802_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx802_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("176_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("185_1275600007.84296") :method .annotate 'line', 4 - new $P775, "ResizablePMCArray" - push $P775, "self" - .return ($P775) + new $P804, "ResizablePMCArray" + push $P804, "self" + .return ($P804) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("177_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("186_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx779_tgt - .local int rx779_pos - .local int rx779_off - .local int rx779_eos - .local int rx779_rep - .local pmc rx779_cur - (rx779_cur, rx779_pos, rx779_tgt) = self."!cursor_start"() - rx779_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx779_cur + .local string rx808_tgt + .local int rx808_pos + .local int rx808_off + .local int rx808_eos + .local int rx808_rep + .local pmc rx808_cur + (rx808_cur, rx808_pos, rx808_tgt) = self."!cursor_start"() + rx808_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx808_cur .local pmc match .lex "$/", match - length rx779_eos, rx779_tgt - gt rx779_pos, rx779_eos, rx779_done - set rx779_off, 0 - lt rx779_pos, 2, rx779_start - sub rx779_off, rx779_pos, 1 - substr rx779_tgt, rx779_tgt, rx779_off - rx779_start: + length rx808_eos, rx808_tgt + gt rx808_pos, rx808_eos, rx808_done + set rx808_off, 0 + lt rx808_pos, 2, rx808_start + sub rx808_off, rx808_pos, 1 + substr rx808_tgt, rx808_tgt, rx808_off + rx808_start: $I10 = self.'from'() - ne $I10, -1, rxscan783_done - goto rxscan783_scan - rxscan783_loop: - ($P10) = rx779_cur."from"() + ne $I10, -1, rxscan812_done + goto rxscan812_scan + rxscan812_loop: + ($P10) = rx808_cur."from"() inc $P10 - set rx779_pos, $P10 - ge rx779_pos, rx779_eos, rxscan783_done - rxscan783_scan: - set_addr $I10, rxscan783_loop - rx779_cur."!mark_push"(0, rx779_pos, $I10) - rxscan783_done: -.annotate 'line', 367 + set rx808_pos, $P10 + ge rx808_pos, rx808_eos, rxscan812_done + rxscan812_scan: + set_addr $I10, rxscan812_loop + rx808_cur."!mark_push"(0, rx808_pos, $I10) + rxscan812_done: +.annotate 'line', 379 # rx subrule "identifier" subtype=capture negate= - rx779_cur."!cursor_pos"(rx779_pos) - $P10 = rx779_cur."identifier"() - unless $P10, rx779_fail - rx779_cur."!mark_push"(0, -1, 0, $P10) + rx808_cur."!cursor_pos"(rx808_pos) + $P10 = rx808_cur."identifier"() + unless $P10, rx808_fail + rx808_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("identifier") - rx779_pos = $P10."pos"() + rx808_pos = $P10."pos"() # rx enumcharlist negate=0 zerowidth - ge rx779_pos, rx779_eos, rx779_fail - sub $I10, rx779_pos, rx779_off - substr $S10, rx779_tgt, $I10, 1 + ge rx808_pos, rx808_eos, rx808_fail + sub $I10, rx808_pos, rx808_off + substr $S10, rx808_tgt, $I10, 1 index $I11, "(", $S10 - lt $I11, 0, rx779_fail + lt $I11, 0, rx808_fail # rx subrule "args" subtype=capture negate= - rx779_cur."!cursor_pos"(rx779_pos) - $P10 = rx779_cur."args"() - unless $P10, rx779_fail - rx779_cur."!mark_push"(0, -1, 0, $P10) + rx808_cur."!cursor_pos"(rx808_pos) + $P10 = rx808_cur."args"() + unless $P10, rx808_fail + rx808_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("args") - rx779_pos = $P10."pos"() -.annotate 'line', 366 + rx808_pos = $P10."pos"() +.annotate 'line', 378 # rx pass - rx779_cur."!cursor_pass"(rx779_pos, "term:sym") - rx779_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx779_pos) - .return (rx779_cur) - rx779_fail: -.annotate 'line', 4 - (rx779_rep, rx779_pos, $I10, $P10) = rx779_cur."!mark_fail"(0) - lt rx779_pos, -1, rx779_done - eq rx779_pos, -1, rx779_fail + rx808_cur."!cursor_pass"(rx808_pos, "term:sym") + rx808_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx808_pos) + .return (rx808_cur) + rx808_fail: +.annotate 'line', 4 + (rx808_rep, rx808_pos, $I10, $P10) = rx808_cur."!mark_fail"(0) + lt rx808_pos, -1, rx808_done + eq rx808_pos, -1, rx808_fail jump $I10 - rx779_done: - rx779_cur."!cursor_fail"() - rx779_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx779_cur) + rx808_done: + rx808_cur."!cursor_fail"() + rx808_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx808_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("178_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("187_1275600007.84296") :method .annotate 'line', 4 - $P781 = self."!PREFIX__!subrule"("identifier", "") - new $P782, "ResizablePMCArray" - push $P782, $P781 - .return ($P782) + $P810 = self."!PREFIX__!subrule"("identifier", "") + new $P811, "ResizablePMCArray" + push $P811, $P810 + .return ($P811) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("179_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("188_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx785_tgt - .local int rx785_pos - .local int rx785_off - .local int rx785_eos - .local int rx785_rep - .local pmc rx785_cur - (rx785_cur, rx785_pos, rx785_tgt) = self."!cursor_start"() - rx785_cur."!cursor_debug"("START ", "term:sym") - rx785_cur."!cursor_caparray"("args") - .lex unicode:"$\x{a2}", rx785_cur + .local string rx814_tgt + .local int rx814_pos + .local int rx814_off + .local int rx814_eos + .local int rx814_rep + .local pmc rx814_cur + (rx814_cur, rx814_pos, rx814_tgt) = self."!cursor_start"() + rx814_cur."!cursor_debug"("START ", "term:sym") + rx814_cur."!cursor_caparray"("args") + .lex unicode:"$\x{a2}", rx814_cur .local pmc match .lex "$/", match - length rx785_eos, rx785_tgt - gt rx785_pos, rx785_eos, rx785_done - set rx785_off, 0 - lt rx785_pos, 2, rx785_start - sub rx785_off, rx785_pos, 1 - substr rx785_tgt, rx785_tgt, rx785_off - rx785_start: + length rx814_eos, rx814_tgt + gt rx814_pos, rx814_eos, rx814_done + set rx814_off, 0 + lt rx814_pos, 2, rx814_start + sub rx814_off, rx814_pos, 1 + substr rx814_tgt, rx814_tgt, rx814_off + rx814_start: $I10 = self.'from'() - ne $I10, -1, rxscan789_done - goto rxscan789_scan - rxscan789_loop: - ($P10) = rx785_cur."from"() + ne $I10, -1, rxscan818_done + goto rxscan818_scan + rxscan818_loop: + ($P10) = rx814_cur."from"() inc $P10 - set rx785_pos, $P10 - ge rx785_pos, rx785_eos, rxscan789_done - rxscan789_scan: - set_addr $I10, rxscan789_loop - rx785_cur."!mark_push"(0, rx785_pos, $I10) - rxscan789_done: -.annotate 'line', 371 + set rx814_pos, $P10 + ge rx814_pos, rx814_eos, rxscan818_done + rxscan818_scan: + set_addr $I10, rxscan818_loop + rx814_cur."!mark_push"(0, rx814_pos, $I10) + rxscan818_done: +.annotate 'line', 383 # rx subrule "name" subtype=capture negate= - rx785_cur."!cursor_pos"(rx785_pos) - $P10 = rx785_cur."name"() - unless $P10, rx785_fail - rx785_cur."!mark_push"(0, -1, 0, $P10) + rx814_cur."!cursor_pos"(rx814_pos) + $P10 = rx814_cur."name"() + unless $P10, rx814_fail + rx814_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("name") - rx785_pos = $P10."pos"() - # rx rxquantr790 ** 0..1 - set_addr $I791, rxquantr790_done - rx785_cur."!mark_push"(0, rx785_pos, $I791) - rxquantr790_loop: + rx814_pos = $P10."pos"() + # rx rxquantr819 ** 0..1 + set_addr $I820, rxquantr819_done + rx814_cur."!mark_push"(0, rx814_pos, $I820) + rxquantr819_loop: # rx subrule "args" subtype=capture negate= - rx785_cur."!cursor_pos"(rx785_pos) - $P10 = rx785_cur."args"() - unless $P10, rx785_fail - rx785_cur."!mark_push"(0, -1, 0, $P10) + rx814_cur."!cursor_pos"(rx814_pos) + $P10 = rx814_cur."args"() + unless $P10, rx814_fail + rx814_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("args") - rx785_pos = $P10."pos"() - (rx785_rep) = rx785_cur."!mark_commit"($I791) - rxquantr790_done: -.annotate 'line', 370 - # rx pass - rx785_cur."!cursor_pass"(rx785_pos, "term:sym") - rx785_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx785_pos) - .return (rx785_cur) - rx785_fail: -.annotate 'line', 4 - (rx785_rep, rx785_pos, $I10, $P10) = rx785_cur."!mark_fail"(0) - lt rx785_pos, -1, rx785_done - eq rx785_pos, -1, rx785_fail + rx814_pos = $P10."pos"() + (rx814_rep) = rx814_cur."!mark_commit"($I820) + rxquantr819_done: +.annotate 'line', 382 + # rx pass + rx814_cur."!cursor_pass"(rx814_pos, "term:sym") + rx814_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx814_pos) + .return (rx814_cur) + rx814_fail: +.annotate 'line', 4 + (rx814_rep, rx814_pos, $I10, $P10) = rx814_cur."!mark_fail"(0) + lt rx814_pos, -1, rx814_done + eq rx814_pos, -1, rx814_fail jump $I10 - rx785_done: - rx785_cur."!cursor_fail"() - rx785_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx785_cur) + rx814_done: + rx814_cur."!cursor_fail"() + rx814_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx814_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("180_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("189_1275600007.84296") :method .annotate 'line', 4 - $P787 = self."!PREFIX__!subrule"("name", "") - new $P788, "ResizablePMCArray" - push $P788, $P787 - .return ($P788) + $P816 = self."!PREFIX__!subrule"("name", "") + new $P817, "ResizablePMCArray" + push $P817, $P816 + .return ($P817) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("181_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("190_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx793_tgt - .local int rx793_pos - .local int rx793_off - .local int rx793_eos - .local int rx793_rep - .local pmc rx793_cur - (rx793_cur, rx793_pos, rx793_tgt) = self."!cursor_start"() - rx793_cur."!cursor_debug"("START ", "term:sym") - rx793_cur."!cursor_caparray"("args") - .lex unicode:"$\x{a2}", rx793_cur + .local string rx822_tgt + .local int rx822_pos + .local int rx822_off + .local int rx822_eos + .local int rx822_rep + .local pmc rx822_cur + (rx822_cur, rx822_pos, rx822_tgt) = self."!cursor_start"() + rx822_cur."!cursor_debug"("START ", "term:sym") + rx822_cur."!cursor_caparray"("args") + .lex unicode:"$\x{a2}", rx822_cur .local pmc match .lex "$/", match - length rx793_eos, rx793_tgt - gt rx793_pos, rx793_eos, rx793_done - set rx793_off, 0 - lt rx793_pos, 2, rx793_start - sub rx793_off, rx793_pos, 1 - substr rx793_tgt, rx793_tgt, rx793_off - rx793_start: + length rx822_eos, rx822_tgt + gt rx822_pos, rx822_eos, rx822_done + set rx822_off, 0 + lt rx822_pos, 2, rx822_start + sub rx822_off, rx822_pos, 1 + substr rx822_tgt, rx822_tgt, rx822_off + rx822_start: $I10 = self.'from'() - ne $I10, -1, rxscan796_done - goto rxscan796_scan - rxscan796_loop: - ($P10) = rx793_cur."from"() + ne $I10, -1, rxscan825_done + goto rxscan825_scan + rxscan825_loop: + ($P10) = rx822_cur."from"() inc $P10 - set rx793_pos, $P10 - ge rx793_pos, rx793_eos, rxscan796_done - rxscan796_scan: - set_addr $I10, rxscan796_loop - rx793_cur."!mark_push"(0, rx793_pos, $I10) - rxscan796_done: -.annotate 'line', 375 + set rx822_pos, $P10 + ge rx822_pos, rx822_eos, rxscan825_done + rxscan825_scan: + set_addr $I10, rxscan825_loop + rx822_cur."!mark_push"(0, rx822_pos, $I10) + rxscan825_done: +.annotate 'line', 387 # rx literal "pir::" - add $I11, rx793_pos, 5 - gt $I11, rx793_eos, rx793_fail - sub $I11, rx793_pos, rx793_off - substr $S10, rx793_tgt, $I11, 5 - ne $S10, "pir::", rx793_fail - add rx793_pos, 5 + add $I11, rx822_pos, 5 + gt $I11, rx822_eos, rx822_fail + sub $I11, rx822_pos, rx822_off + substr $S10, rx822_tgt, $I11, 5 + ne $S10, "pir::", rx822_fail + add rx822_pos, 5 # rx subcapture "op" - set_addr $I10, rxcap_797_fail - rx793_cur."!mark_push"(0, rx793_pos, $I10) + set_addr $I10, rxcap_826_fail + rx822_cur."!mark_push"(0, rx822_pos, $I10) # rx charclass_q w r 1..-1 - sub $I10, rx793_pos, rx793_off - find_not_cclass $I11, 8192, rx793_tgt, $I10, rx793_eos + sub $I10, rx822_pos, rx822_off + find_not_cclass $I11, 8192, rx822_tgt, $I10, rx822_eos add $I12, $I10, 1 - lt $I11, $I12, rx793_fail - add rx793_pos, rx793_off, $I11 - set_addr $I10, rxcap_797_fail - ($I12, $I11) = rx793_cur."!mark_peek"($I10) - rx793_cur."!cursor_pos"($I11) - ($P10) = rx793_cur."!cursor_start"() - $P10."!cursor_pass"(rx793_pos, "") - rx793_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, $I12, rx822_fail + add rx822_pos, rx822_off, $I11 + set_addr $I10, rxcap_826_fail + ($I12, $I11) = rx822_cur."!mark_peek"($I10) + rx822_cur."!cursor_pos"($I11) + ($P10) = rx822_cur."!cursor_start"() + $P10."!cursor_pass"(rx822_pos, "") + rx822_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("op") - goto rxcap_797_done - rxcap_797_fail: - goto rx793_fail - rxcap_797_done: - # rx rxquantr798 ** 0..1 - set_addr $I799, rxquantr798_done - rx793_cur."!mark_push"(0, rx793_pos, $I799) - rxquantr798_loop: + goto rxcap_826_done + rxcap_826_fail: + goto rx822_fail + rxcap_826_done: + # rx rxquantr827 ** 0..1 + set_addr $I828, rxquantr827_done + rx822_cur."!mark_push"(0, rx822_pos, $I828) + rxquantr827_loop: # rx subrule "args" subtype=capture negate= - rx793_cur."!cursor_pos"(rx793_pos) - $P10 = rx793_cur."args"() - unless $P10, rx793_fail - rx793_cur."!mark_push"(0, -1, 0, $P10) + rx822_cur."!cursor_pos"(rx822_pos) + $P10 = rx822_cur."args"() + unless $P10, rx822_fail + rx822_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("args") - rx793_pos = $P10."pos"() - (rx793_rep) = rx793_cur."!mark_commit"($I799) - rxquantr798_done: -.annotate 'line', 374 + rx822_pos = $P10."pos"() + (rx822_rep) = rx822_cur."!mark_commit"($I828) + rxquantr827_done: +.annotate 'line', 386 # rx pass - rx793_cur."!cursor_pass"(rx793_pos, "term:sym") - rx793_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx793_pos) - .return (rx793_cur) - rx793_fail: -.annotate 'line', 4 - (rx793_rep, rx793_pos, $I10, $P10) = rx793_cur."!mark_fail"(0) - lt rx793_pos, -1, rx793_done - eq rx793_pos, -1, rx793_fail + rx822_cur."!cursor_pass"(rx822_pos, "term:sym") + rx822_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx822_pos) + .return (rx822_cur) + rx822_fail: +.annotate 'line', 4 + (rx822_rep, rx822_pos, $I10, $P10) = rx822_cur."!mark_fail"(0) + lt rx822_pos, -1, rx822_done + eq rx822_pos, -1, rx822_fail jump $I10 - rx793_done: - rx793_cur."!cursor_fail"() - rx793_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx793_cur) + rx822_done: + rx822_cur."!cursor_fail"() + rx822_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx822_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("182_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("191_1275600007.84296") :method .annotate 'line', 4 - new $P795, "ResizablePMCArray" - push $P795, "pir::" - .return ($P795) + new $P824, "ResizablePMCArray" + push $P824, "pir::" + .return ($P824) .end .namespace ["NQP";"Grammar"] -.sub "args" :subid("183_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "args" :subid("192_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx801_tgt - .local int rx801_pos - .local int rx801_off - .local int rx801_eos - .local int rx801_rep - .local pmc rx801_cur - (rx801_cur, rx801_pos, rx801_tgt) = self."!cursor_start"() - rx801_cur."!cursor_debug"("START ", "args") - .lex unicode:"$\x{a2}", rx801_cur + .local string rx830_tgt + .local int rx830_pos + .local int rx830_off + .local int rx830_eos + .local int rx830_rep + .local pmc rx830_cur + (rx830_cur, rx830_pos, rx830_tgt) = self."!cursor_start"() + rx830_cur."!cursor_debug"("START ", "args") + .lex unicode:"$\x{a2}", rx830_cur .local pmc match .lex "$/", match - length rx801_eos, rx801_tgt - gt rx801_pos, rx801_eos, rx801_done - set rx801_off, 0 - lt rx801_pos, 2, rx801_start - sub rx801_off, rx801_pos, 1 - substr rx801_tgt, rx801_tgt, rx801_off - rx801_start: + length rx830_eos, rx830_tgt + gt rx830_pos, rx830_eos, rx830_done + set rx830_off, 0 + lt rx830_pos, 2, rx830_start + sub rx830_off, rx830_pos, 1 + substr rx830_tgt, rx830_tgt, rx830_off + rx830_start: $I10 = self.'from'() - ne $I10, -1, rxscan805_done - goto rxscan805_scan - rxscan805_loop: - ($P10) = rx801_cur."from"() + ne $I10, -1, rxscan834_done + goto rxscan834_scan + rxscan834_loop: + ($P10) = rx830_cur."from"() inc $P10 - set rx801_pos, $P10 - ge rx801_pos, rx801_eos, rxscan805_done - rxscan805_scan: - set_addr $I10, rxscan805_loop - rx801_cur."!mark_push"(0, rx801_pos, $I10) - rxscan805_done: -.annotate 'line', 379 + set rx830_pos, $P10 + ge rx830_pos, rx830_eos, rxscan834_done + rxscan834_scan: + set_addr $I10, rxscan834_loop + rx830_cur."!mark_push"(0, rx830_pos, $I10) + rxscan834_done: +.annotate 'line', 391 # rx literal "(" - add $I11, rx801_pos, 1 - gt $I11, rx801_eos, rx801_fail - sub $I11, rx801_pos, rx801_off - substr $S10, rx801_tgt, $I11, 1 - ne $S10, "(", rx801_fail - add rx801_pos, 1 + add $I11, rx830_pos, 1 + gt $I11, rx830_eos, rx830_fail + sub $I11, rx830_pos, rx830_off + substr $S10, rx830_tgt, $I11, 1 + ne $S10, "(", rx830_fail + add rx830_pos, 1 # rx subrule "arglist" subtype=capture negate= - rx801_cur."!cursor_pos"(rx801_pos) - $P10 = rx801_cur."arglist"() - unless $P10, rx801_fail - rx801_cur."!mark_push"(0, -1, 0, $P10) + rx830_cur."!cursor_pos"(rx830_pos) + $P10 = rx830_cur."arglist"() + unless $P10, rx830_fail + rx830_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("arglist") - rx801_pos = $P10."pos"() + rx830_pos = $P10."pos"() # rx literal ")" - add $I11, rx801_pos, 1 - gt $I11, rx801_eos, rx801_fail - sub $I11, rx801_pos, rx801_off - substr $S10, rx801_tgt, $I11, 1 - ne $S10, ")", rx801_fail - add rx801_pos, 1 + add $I11, rx830_pos, 1 + gt $I11, rx830_eos, rx830_fail + sub $I11, rx830_pos, rx830_off + substr $S10, rx830_tgt, $I11, 1 + ne $S10, ")", rx830_fail + add rx830_pos, 1 # rx pass - rx801_cur."!cursor_pass"(rx801_pos, "args") - rx801_cur."!cursor_debug"("PASS ", "args", " at pos=", rx801_pos) - .return (rx801_cur) - rx801_fail: -.annotate 'line', 4 - (rx801_rep, rx801_pos, $I10, $P10) = rx801_cur."!mark_fail"(0) - lt rx801_pos, -1, rx801_done - eq rx801_pos, -1, rx801_fail + rx830_cur."!cursor_pass"(rx830_pos, "args") + rx830_cur."!cursor_debug"("PASS ", "args", " at pos=", rx830_pos) + .return (rx830_cur) + rx830_fail: +.annotate 'line', 4 + (rx830_rep, rx830_pos, $I10, $P10) = rx830_cur."!mark_fail"(0) + lt rx830_pos, -1, rx830_done + eq rx830_pos, -1, rx830_fail jump $I10 - rx801_done: - rx801_cur."!cursor_fail"() - rx801_cur."!cursor_debug"("FAIL ", "args") - .return (rx801_cur) + rx830_done: + rx830_cur."!cursor_fail"() + rx830_cur."!cursor_debug"("FAIL ", "args") + .return (rx830_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__args" :subid("184_1275511697.61926") :method +.sub "!PREFIX__args" :subid("193_1275600007.84296") :method .annotate 'line', 4 - $P803 = self."!PREFIX__!subrule"("arglist", "(") - new $P804, "ResizablePMCArray" - push $P804, $P803 - .return ($P804) + $P832 = self."!PREFIX__!subrule"("arglist", "(") + new $P833, "ResizablePMCArray" + push $P833, $P832 + .return ($P833) .end .namespace ["NQP";"Grammar"] -.sub "arglist" :subid("185_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "arglist" :subid("194_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx807_tgt - .local int rx807_pos - .local int rx807_off - .local int rx807_eos - .local int rx807_rep - .local pmc rx807_cur - (rx807_cur, rx807_pos, rx807_tgt) = self."!cursor_start"() - rx807_cur."!cursor_debug"("START ", "arglist") - .lex unicode:"$\x{a2}", rx807_cur + .local string rx836_tgt + .local int rx836_pos + .local int rx836_off + .local int rx836_eos + .local int rx836_rep + .local pmc rx836_cur + (rx836_cur, rx836_pos, rx836_tgt) = self."!cursor_start"() + rx836_cur."!cursor_debug"("START ", "arglist") + .lex unicode:"$\x{a2}", rx836_cur .local pmc match .lex "$/", match - length rx807_eos, rx807_tgt - gt rx807_pos, rx807_eos, rx807_done - set rx807_off, 0 - lt rx807_pos, 2, rx807_start - sub rx807_off, rx807_pos, 1 - substr rx807_tgt, rx807_tgt, rx807_off - rx807_start: + length rx836_eos, rx836_tgt + gt rx836_pos, rx836_eos, rx836_done + set rx836_off, 0 + lt rx836_pos, 2, rx836_start + sub rx836_off, rx836_pos, 1 + substr rx836_tgt, rx836_tgt, rx836_off + rx836_start: $I10 = self.'from'() - ne $I10, -1, rxscan811_done - goto rxscan811_scan - rxscan811_loop: - ($P10) = rx807_cur."from"() + ne $I10, -1, rxscan840_done + goto rxscan840_scan + rxscan840_loop: + ($P10) = rx836_cur."from"() inc $P10 - set rx807_pos, $P10 - ge rx807_pos, rx807_eos, rxscan811_done - rxscan811_scan: - set_addr $I10, rxscan811_loop - rx807_cur."!mark_push"(0, rx807_pos, $I10) - rxscan811_done: -.annotate 'line', 383 + set rx836_pos, $P10 + ge rx836_pos, rx836_eos, rxscan840_done + rxscan840_scan: + set_addr $I10, rxscan840_loop + rx836_cur."!mark_push"(0, rx836_pos, $I10) + rxscan840_done: +.annotate 'line', 395 # rx subrule "ws" subtype=method negate= - rx807_cur."!cursor_pos"(rx807_pos) - $P10 = rx807_cur."ws"() - unless $P10, rx807_fail - rx807_pos = $P10."pos"() - alt812_0: -.annotate 'line', 384 - set_addr $I10, alt812_1 - rx807_cur."!mark_push"(0, rx807_pos, $I10) -.annotate 'line', 385 + rx836_cur."!cursor_pos"(rx836_pos) + $P10 = rx836_cur."ws"() + unless $P10, rx836_fail + rx836_pos = $P10."pos"() + alt841_0: +.annotate 'line', 396 + set_addr $I10, alt841_1 + rx836_cur."!mark_push"(0, rx836_pos, $I10) +.annotate 'line', 397 # rx subrule "EXPR" subtype=capture negate= - rx807_cur."!cursor_pos"(rx807_pos) - $P10 = rx807_cur."EXPR"("f=") - unless $P10, rx807_fail - rx807_cur."!mark_push"(0, -1, 0, $P10) + rx836_cur."!cursor_pos"(rx836_pos) + $P10 = rx836_cur."EXPR"("f=") + unless $P10, rx836_fail + rx836_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("EXPR") - rx807_pos = $P10."pos"() - goto alt812_end - alt812_1: - alt812_end: -.annotate 'line', 382 + rx836_pos = $P10."pos"() + goto alt841_end + alt841_1: + alt841_end: +.annotate 'line', 394 # rx pass - rx807_cur."!cursor_pass"(rx807_pos, "arglist") - rx807_cur."!cursor_debug"("PASS ", "arglist", " at pos=", rx807_pos) - .return (rx807_cur) - rx807_fail: -.annotate 'line', 4 - (rx807_rep, rx807_pos, $I10, $P10) = rx807_cur."!mark_fail"(0) - lt rx807_pos, -1, rx807_done - eq rx807_pos, -1, rx807_fail + rx836_cur."!cursor_pass"(rx836_pos, "arglist") + rx836_cur."!cursor_debug"("PASS ", "arglist", " at pos=", rx836_pos) + .return (rx836_cur) + rx836_fail: +.annotate 'line', 4 + (rx836_rep, rx836_pos, $I10, $P10) = rx836_cur."!mark_fail"(0) + lt rx836_pos, -1, rx836_done + eq rx836_pos, -1, rx836_fail jump $I10 - rx807_done: - rx807_cur."!cursor_fail"() - rx807_cur."!cursor_debug"("FAIL ", "arglist") - .return (rx807_cur) + rx836_done: + rx836_cur."!cursor_fail"() + rx836_cur."!cursor_debug"("FAIL ", "arglist") + .return (rx836_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__arglist" :subid("186_1275511697.61926") :method +.sub "!PREFIX__arglist" :subid("195_1275600007.84296") :method .annotate 'line', 4 - $P809 = self."!PREFIX__!subrule"("", "") - new $P810, "ResizablePMCArray" - push $P810, $P809 - .return ($P810) + $P838 = self."!PREFIX__!subrule"("", "") + new $P839, "ResizablePMCArray" + push $P839, $P838 + .return ($P839) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("187_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "term:sym" :subid("196_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx814_tgt - .local int rx814_pos - .local int rx814_off - .local int rx814_eos - .local int rx814_rep - .local pmc rx814_cur - (rx814_cur, rx814_pos, rx814_tgt) = self."!cursor_start"() - rx814_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx814_cur + .local string rx843_tgt + .local int rx843_pos + .local int rx843_off + .local int rx843_eos + .local int rx843_rep + .local pmc rx843_cur + (rx843_cur, rx843_pos, rx843_tgt) = self."!cursor_start"() + rx843_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx843_cur .local pmc match .lex "$/", match - length rx814_eos, rx814_tgt - gt rx814_pos, rx814_eos, rx814_done - set rx814_off, 0 - lt rx814_pos, 2, rx814_start - sub rx814_off, rx814_pos, 1 - substr rx814_tgt, rx814_tgt, rx814_off - rx814_start: + length rx843_eos, rx843_tgt + gt rx843_pos, rx843_eos, rx843_done + set rx843_off, 0 + lt rx843_pos, 2, rx843_start + sub rx843_off, rx843_pos, 1 + substr rx843_tgt, rx843_tgt, rx843_off + rx843_start: $I10 = self.'from'() - ne $I10, -1, rxscan818_done - goto rxscan818_scan - rxscan818_loop: - ($P10) = rx814_cur."from"() + ne $I10, -1, rxscan847_done + goto rxscan847_scan + rxscan847_loop: + ($P10) = rx843_cur."from"() inc $P10 - set rx814_pos, $P10 - ge rx814_pos, rx814_eos, rxscan818_done - rxscan818_scan: - set_addr $I10, rxscan818_loop - rx814_cur."!mark_push"(0, rx814_pos, $I10) - rxscan818_done: -.annotate 'line', 391 + set rx843_pos, $P10 + ge rx843_pos, rx843_eos, rxscan847_done + rxscan847_scan: + set_addr $I10, rxscan847_loop + rx843_cur."!mark_push"(0, rx843_pos, $I10) + rxscan847_done: +.annotate 'line', 403 # rx subrule "value" subtype=capture negate= - rx814_cur."!cursor_pos"(rx814_pos) - $P10 = rx814_cur."value"() - unless $P10, rx814_fail - rx814_cur."!mark_push"(0, -1, 0, $P10) + rx843_cur."!cursor_pos"(rx843_pos) + $P10 = rx843_cur."value"() + unless $P10, rx843_fail + rx843_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("value") - rx814_pos = $P10."pos"() + rx843_pos = $P10."pos"() # rx pass - rx814_cur."!cursor_pass"(rx814_pos, "term:sym") - rx814_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx814_pos) - .return (rx814_cur) - rx814_fail: -.annotate 'line', 4 - (rx814_rep, rx814_pos, $I10, $P10) = rx814_cur."!mark_fail"(0) - lt rx814_pos, -1, rx814_done - eq rx814_pos, -1, rx814_fail + rx843_cur."!cursor_pass"(rx843_pos, "term:sym") + rx843_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx843_pos) + .return (rx843_cur) + rx843_fail: +.annotate 'line', 4 + (rx843_rep, rx843_pos, $I10, $P10) = rx843_cur."!mark_fail"(0) + lt rx843_pos, -1, rx843_done + eq rx843_pos, -1, rx843_fail jump $I10 - rx814_done: - rx814_cur."!cursor_fail"() - rx814_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx814_cur) + rx843_done: + rx843_cur."!cursor_fail"() + rx843_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx843_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("188_1275511697.61926") :method +.sub "!PREFIX__term:sym" :subid("197_1275600007.84296") :method .annotate 'line', 4 - $P816 = self."!PREFIX__!subrule"("value", "") - new $P817, "ResizablePMCArray" - push $P817, $P816 - .return ($P817) + $P845 = self."!PREFIX__!subrule"("value", "") + new $P846, "ResizablePMCArray" + push $P846, $P845 + .return ($P846) .end .namespace ["NQP";"Grammar"] -.sub "value" :subid("189_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "value" :subid("198_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx820_tgt - .local int rx820_pos - .local int rx820_off - .local int rx820_eos - .local int rx820_rep - .local pmc rx820_cur - (rx820_cur, rx820_pos, rx820_tgt) = self."!cursor_start"() - rx820_cur."!cursor_debug"("START ", "value") - .lex unicode:"$\x{a2}", rx820_cur + .local string rx849_tgt + .local int rx849_pos + .local int rx849_off + .local int rx849_eos + .local int rx849_rep + .local pmc rx849_cur + (rx849_cur, rx849_pos, rx849_tgt) = self."!cursor_start"() + rx849_cur."!cursor_debug"("START ", "value") + .lex unicode:"$\x{a2}", rx849_cur .local pmc match .lex "$/", match - length rx820_eos, rx820_tgt - gt rx820_pos, rx820_eos, rx820_done - set rx820_off, 0 - lt rx820_pos, 2, rx820_start - sub rx820_off, rx820_pos, 1 - substr rx820_tgt, rx820_tgt, rx820_off - rx820_start: + length rx849_eos, rx849_tgt + gt rx849_pos, rx849_eos, rx849_done + set rx849_off, 0 + lt rx849_pos, 2, rx849_start + sub rx849_off, rx849_pos, 1 + substr rx849_tgt, rx849_tgt, rx849_off + rx849_start: $I10 = self.'from'() - ne $I10, -1, rxscan825_done - goto rxscan825_scan - rxscan825_loop: - ($P10) = rx820_cur."from"() + ne $I10, -1, rxscan854_done + goto rxscan854_scan + rxscan854_loop: + ($P10) = rx849_cur."from"() inc $P10 - set rx820_pos, $P10 - ge rx820_pos, rx820_eos, rxscan825_done - rxscan825_scan: - set_addr $I10, rxscan825_loop - rx820_cur."!mark_push"(0, rx820_pos, $I10) - rxscan825_done: - alt826_0: -.annotate 'line', 393 - set_addr $I10, alt826_1 - rx820_cur."!mark_push"(0, rx820_pos, $I10) -.annotate 'line', 394 + set rx849_pos, $P10 + ge rx849_pos, rx849_eos, rxscan854_done + rxscan854_scan: + set_addr $I10, rxscan854_loop + rx849_cur."!mark_push"(0, rx849_pos, $I10) + rxscan854_done: + alt855_0: +.annotate 'line', 405 + set_addr $I10, alt855_1 + rx849_cur."!mark_push"(0, rx849_pos, $I10) +.annotate 'line', 406 # rx subrule "quote" subtype=capture negate= - rx820_cur."!cursor_pos"(rx820_pos) - $P10 = rx820_cur."quote"() - unless $P10, rx820_fail - rx820_cur."!mark_push"(0, -1, 0, $P10) + rx849_cur."!cursor_pos"(rx849_pos) + $P10 = rx849_cur."quote"() + unless $P10, rx849_fail + rx849_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quote") - rx820_pos = $P10."pos"() - goto alt826_end - alt826_1: -.annotate 'line', 395 + rx849_pos = $P10."pos"() + goto alt855_end + alt855_1: +.annotate 'line', 407 # rx subrule "number" subtype=capture negate= - rx820_cur."!cursor_pos"(rx820_pos) - $P10 = rx820_cur."number"() - unless $P10, rx820_fail - rx820_cur."!mark_push"(0, -1, 0, $P10) + rx849_cur."!cursor_pos"(rx849_pos) + $P10 = rx849_cur."number"() + unless $P10, rx849_fail + rx849_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("number") - rx820_pos = $P10."pos"() - alt826_end: -.annotate 'line', 393 + rx849_pos = $P10."pos"() + alt855_end: +.annotate 'line', 405 # rx pass - rx820_cur."!cursor_pass"(rx820_pos, "value") - rx820_cur."!cursor_debug"("PASS ", "value", " at pos=", rx820_pos) - .return (rx820_cur) - rx820_fail: -.annotate 'line', 4 - (rx820_rep, rx820_pos, $I10, $P10) = rx820_cur."!mark_fail"(0) - lt rx820_pos, -1, rx820_done - eq rx820_pos, -1, rx820_fail + rx849_cur."!cursor_pass"(rx849_pos, "value") + rx849_cur."!cursor_debug"("PASS ", "value", " at pos=", rx849_pos) + .return (rx849_cur) + rx849_fail: +.annotate 'line', 4 + (rx849_rep, rx849_pos, $I10, $P10) = rx849_cur."!mark_fail"(0) + lt rx849_pos, -1, rx849_done + eq rx849_pos, -1, rx849_fail jump $I10 - rx820_done: - rx820_cur."!cursor_fail"() - rx820_cur."!cursor_debug"("FAIL ", "value") - .return (rx820_cur) + rx849_done: + rx849_cur."!cursor_fail"() + rx849_cur."!cursor_debug"("FAIL ", "value") + .return (rx849_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__value" :subid("190_1275511697.61926") :method +.sub "!PREFIX__value" :subid("199_1275600007.84296") :method .annotate 'line', 4 - $P822 = self."!PREFIX__!subrule"("number", "") - $P823 = self."!PREFIX__!subrule"("quote", "") - new $P824, "ResizablePMCArray" - push $P824, $P822 - push $P824, $P823 - .return ($P824) + $P851 = self."!PREFIX__!subrule"("number", "") + $P852 = self."!PREFIX__!subrule"("quote", "") + new $P853, "ResizablePMCArray" + push $P853, $P851 + push $P853, $P852 + .return ($P853) .end .namespace ["NQP";"Grammar"] -.sub "number" :subid("191_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "number" :subid("200_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx828_tgt - .local int rx828_pos - .local int rx828_off - .local int rx828_eos - .local int rx828_rep - .local pmc rx828_cur - (rx828_cur, rx828_pos, rx828_tgt) = self."!cursor_start"() - rx828_cur."!cursor_debug"("START ", "number") - .lex unicode:"$\x{a2}", rx828_cur + .local string rx857_tgt + .local int rx857_pos + .local int rx857_off + .local int rx857_eos + .local int rx857_rep + .local pmc rx857_cur + (rx857_cur, rx857_pos, rx857_tgt) = self."!cursor_start"() + rx857_cur."!cursor_debug"("START ", "number") + .lex unicode:"$\x{a2}", rx857_cur .local pmc match .lex "$/", match - length rx828_eos, rx828_tgt - gt rx828_pos, rx828_eos, rx828_done - set rx828_off, 0 - lt rx828_pos, 2, rx828_start - sub rx828_off, rx828_pos, 1 - substr rx828_tgt, rx828_tgt, rx828_off - rx828_start: + length rx857_eos, rx857_tgt + gt rx857_pos, rx857_eos, rx857_done + set rx857_off, 0 + lt rx857_pos, 2, rx857_start + sub rx857_off, rx857_pos, 1 + substr rx857_tgt, rx857_tgt, rx857_off + rx857_start: $I10 = self.'from'() - ne $I10, -1, rxscan831_done - goto rxscan831_scan - rxscan831_loop: - ($P10) = rx828_cur."from"() + ne $I10, -1, rxscan860_done + goto rxscan860_scan + rxscan860_loop: + ($P10) = rx857_cur."from"() inc $P10 - set rx828_pos, $P10 - ge rx828_pos, rx828_eos, rxscan831_done - rxscan831_scan: - set_addr $I10, rxscan831_loop - rx828_cur."!mark_push"(0, rx828_pos, $I10) - rxscan831_done: -.annotate 'line', 399 + set rx857_pos, $P10 + ge rx857_pos, rx857_eos, rxscan860_done + rxscan860_scan: + set_addr $I10, rxscan860_loop + rx857_cur."!mark_push"(0, rx857_pos, $I10) + rxscan860_done: +.annotate 'line', 411 # rx subcapture "sign" - set_addr $I10, rxcap_834_fail - rx828_cur."!mark_push"(0, rx828_pos, $I10) - # rx rxquantr832 ** 0..1 - set_addr $I833, rxquantr832_done - rx828_cur."!mark_push"(0, rx828_pos, $I833) - rxquantr832_loop: + set_addr $I10, rxcap_863_fail + rx857_cur."!mark_push"(0, rx857_pos, $I10) + # rx rxquantr861 ** 0..1 + set_addr $I862, rxquantr861_done + rx857_cur."!mark_push"(0, rx857_pos, $I862) + rxquantr861_loop: # rx enumcharlist negate=0 - ge rx828_pos, rx828_eos, rx828_fail - sub $I10, rx828_pos, rx828_off - substr $S10, rx828_tgt, $I10, 1 + ge rx857_pos, rx857_eos, rx857_fail + sub $I10, rx857_pos, rx857_off + substr $S10, rx857_tgt, $I10, 1 index $I11, "+-", $S10 - lt $I11, 0, rx828_fail - inc rx828_pos - (rx828_rep) = rx828_cur."!mark_commit"($I833) - rxquantr832_done: - set_addr $I10, rxcap_834_fail - ($I12, $I11) = rx828_cur."!mark_peek"($I10) - rx828_cur."!cursor_pos"($I11) - ($P10) = rx828_cur."!cursor_start"() - $P10."!cursor_pass"(rx828_pos, "") - rx828_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, 0, rx857_fail + inc rx857_pos + (rx857_rep) = rx857_cur."!mark_commit"($I862) + rxquantr861_done: + set_addr $I10, rxcap_863_fail + ($I12, $I11) = rx857_cur."!mark_peek"($I10) + rx857_cur."!cursor_pos"($I11) + ($P10) = rx857_cur."!cursor_start"() + $P10."!cursor_pass"(rx857_pos, "") + rx857_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sign") - goto rxcap_834_done - rxcap_834_fail: - goto rx828_fail - rxcap_834_done: - alt835_0: -.annotate 'line', 400 - set_addr $I10, alt835_1 - rx828_cur."!mark_push"(0, rx828_pos, $I10) + goto rxcap_863_done + rxcap_863_fail: + goto rx857_fail + rxcap_863_done: + alt864_0: +.annotate 'line', 412 + set_addr $I10, alt864_1 + rx857_cur."!mark_push"(0, rx857_pos, $I10) # rx subrule "dec_number" subtype=capture negate= - rx828_cur."!cursor_pos"(rx828_pos) - $P10 = rx828_cur."dec_number"() - unless $P10, rx828_fail - rx828_cur."!mark_push"(0, -1, 0, $P10) + rx857_cur."!cursor_pos"(rx857_pos) + $P10 = rx857_cur."dec_number"() + unless $P10, rx857_fail + rx857_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("dec_number") - rx828_pos = $P10."pos"() - goto alt835_end - alt835_1: + rx857_pos = $P10."pos"() + goto alt864_end + alt864_1: # rx subrule "integer" subtype=capture negate= - rx828_cur."!cursor_pos"(rx828_pos) - $P10 = rx828_cur."integer"() - unless $P10, rx828_fail - rx828_cur."!mark_push"(0, -1, 0, $P10) + rx857_cur."!cursor_pos"(rx857_pos) + $P10 = rx857_cur."integer"() + unless $P10, rx857_fail + rx857_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("integer") - rx828_pos = $P10."pos"() - alt835_end: -.annotate 'line', 398 + rx857_pos = $P10."pos"() + alt864_end: +.annotate 'line', 410 # rx pass - rx828_cur."!cursor_pass"(rx828_pos, "number") - rx828_cur."!cursor_debug"("PASS ", "number", " at pos=", rx828_pos) - .return (rx828_cur) - rx828_fail: -.annotate 'line', 4 - (rx828_rep, rx828_pos, $I10, $P10) = rx828_cur."!mark_fail"(0) - lt rx828_pos, -1, rx828_done - eq rx828_pos, -1, rx828_fail + rx857_cur."!cursor_pass"(rx857_pos, "number") + rx857_cur."!cursor_debug"("PASS ", "number", " at pos=", rx857_pos) + .return (rx857_cur) + rx857_fail: +.annotate 'line', 4 + (rx857_rep, rx857_pos, $I10, $P10) = rx857_cur."!mark_fail"(0) + lt rx857_pos, -1, rx857_done + eq rx857_pos, -1, rx857_fail jump $I10 - rx828_done: - rx828_cur."!cursor_fail"() - rx828_cur."!cursor_debug"("FAIL ", "number") - .return (rx828_cur) + rx857_done: + rx857_cur."!cursor_fail"() + rx857_cur."!cursor_debug"("FAIL ", "number") + .return (rx857_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__number" :subid("192_1275511697.61926") :method +.sub "!PREFIX__number" :subid("201_1275600007.84296") :method .annotate 'line', 4 - new $P830, "ResizablePMCArray" - push $P830, "" - .return ($P830) + new $P859, "ResizablePMCArray" + push $P859, "" + .return ($P859) .end .namespace ["NQP";"Grammar"] -.sub "quote" :subid("193_1275511697.61926") :method -.annotate 'line', 403 - $P837 = self."!protoregex"("quote") - .return ($P837) +.sub "quote" :subid("202_1275600007.84296") :method +.annotate 'line', 415 + $P866 = self."!protoregex"("quote") + .return ($P866) .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__quote" :subid("194_1275511697.61926") :method -.annotate 'line', 403 - $P839 = self."!PREFIX__!protoregex"("quote") - .return ($P839) +.sub "!PREFIX__quote" :subid("203_1275600007.84296") :method +.annotate 'line', 415 + $P868 = self."!PREFIX__!protoregex"("quote") + .return ($P868) .end .namespace ["NQP";"Grammar"] -.sub "quote:sym" :subid("195_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "quote:sym" :subid("204_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx841_tgt - .local int rx841_pos - .local int rx841_off - .local int rx841_eos - .local int rx841_rep - .local pmc rx841_cur - (rx841_cur, rx841_pos, rx841_tgt) = self."!cursor_start"() - rx841_cur."!cursor_debug"("START ", "quote:sym") - .lex unicode:"$\x{a2}", rx841_cur + .local string rx870_tgt + .local int rx870_pos + .local int rx870_off + .local int rx870_eos + .local int rx870_rep + .local pmc rx870_cur + (rx870_cur, rx870_pos, rx870_tgt) = self."!cursor_start"() + rx870_cur."!cursor_debug"("START ", "quote:sym") + .lex unicode:"$\x{a2}", rx870_cur .local pmc match .lex "$/", match - length rx841_eos, rx841_tgt - gt rx841_pos, rx841_eos, rx841_done - set rx841_off, 0 - lt rx841_pos, 2, rx841_start - sub rx841_off, rx841_pos, 1 - substr rx841_tgt, rx841_tgt, rx841_off - rx841_start: + length rx870_eos, rx870_tgt + gt rx870_pos, rx870_eos, rx870_done + set rx870_off, 0 + lt rx870_pos, 2, rx870_start + sub rx870_off, rx870_pos, 1 + substr rx870_tgt, rx870_tgt, rx870_off + rx870_start: $I10 = self.'from'() - ne $I10, -1, rxscan844_done - goto rxscan844_scan - rxscan844_loop: - ($P10) = rx841_cur."from"() + ne $I10, -1, rxscan873_done + goto rxscan873_scan + rxscan873_loop: + ($P10) = rx870_cur."from"() inc $P10 - set rx841_pos, $P10 - ge rx841_pos, rx841_eos, rxscan844_done - rxscan844_scan: - set_addr $I10, rxscan844_loop - rx841_cur."!mark_push"(0, rx841_pos, $I10) - rxscan844_done: -.annotate 'line', 404 + set rx870_pos, $P10 + ge rx870_pos, rx870_eos, rxscan873_done + rxscan873_scan: + set_addr $I10, rxscan873_loop + rx870_cur."!mark_push"(0, rx870_pos, $I10) + rxscan873_done: +.annotate 'line', 416 # rx enumcharlist negate=0 zerowidth - ge rx841_pos, rx841_eos, rx841_fail - sub $I10, rx841_pos, rx841_off - substr $S10, rx841_tgt, $I10, 1 + ge rx870_pos, rx870_eos, rx870_fail + sub $I10, rx870_pos, rx870_off + substr $S10, rx870_tgt, $I10, 1 index $I11, "'", $S10 - lt $I11, 0, rx841_fail + lt $I11, 0, rx870_fail # rx subrule "quote_EXPR" subtype=capture negate= - rx841_cur."!cursor_pos"(rx841_pos) - $P10 = rx841_cur."quote_EXPR"(":q") - unless $P10, rx841_fail - rx841_cur."!mark_push"(0, -1, 0, $P10) + rx870_cur."!cursor_pos"(rx870_pos) + $P10 = rx870_cur."quote_EXPR"(":q") + unless $P10, rx870_fail + rx870_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quote_EXPR") - rx841_pos = $P10."pos"() + rx870_pos = $P10."pos"() # rx pass - rx841_cur."!cursor_pass"(rx841_pos, "quote:sym") - rx841_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx841_pos) - .return (rx841_cur) - rx841_fail: -.annotate 'line', 4 - (rx841_rep, rx841_pos, $I10, $P10) = rx841_cur."!mark_fail"(0) - lt rx841_pos, -1, rx841_done - eq rx841_pos, -1, rx841_fail + rx870_cur."!cursor_pass"(rx870_pos, "quote:sym") + rx870_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx870_pos) + .return (rx870_cur) + rx870_fail: +.annotate 'line', 4 + (rx870_rep, rx870_pos, $I10, $P10) = rx870_cur."!mark_fail"(0) + lt rx870_pos, -1, rx870_done + eq rx870_pos, -1, rx870_fail jump $I10 - rx841_done: - rx841_cur."!cursor_fail"() - rx841_cur."!cursor_debug"("FAIL ", "quote:sym") - .return (rx841_cur) + rx870_done: + rx870_cur."!cursor_fail"() + rx870_cur."!cursor_debug"("FAIL ", "quote:sym") + .return (rx870_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__quote:sym" :subid("196_1275511697.61926") :method +.sub "!PREFIX__quote:sym" :subid("205_1275600007.84296") :method .annotate 'line', 4 - new $P843, "ResizablePMCArray" - push $P843, "'" - .return ($P843) + new $P872, "ResizablePMCArray" + push $P872, "'" + .return ($P872) .end .namespace ["NQP";"Grammar"] -.sub "quote:sym" :subid("197_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "quote:sym" :subid("206_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx846_tgt - .local int rx846_pos - .local int rx846_off - .local int rx846_eos - .local int rx846_rep - .local pmc rx846_cur - (rx846_cur, rx846_pos, rx846_tgt) = self."!cursor_start"() - rx846_cur."!cursor_debug"("START ", "quote:sym") - .lex unicode:"$\x{a2}", rx846_cur + .local string rx875_tgt + .local int rx875_pos + .local int rx875_off + .local int rx875_eos + .local int rx875_rep + .local pmc rx875_cur + (rx875_cur, rx875_pos, rx875_tgt) = self."!cursor_start"() + rx875_cur."!cursor_debug"("START ", "quote:sym") + .lex unicode:"$\x{a2}", rx875_cur .local pmc match .lex "$/", match - length rx846_eos, rx846_tgt - gt rx846_pos, rx846_eos, rx846_done - set rx846_off, 0 - lt rx846_pos, 2, rx846_start - sub rx846_off, rx846_pos, 1 - substr rx846_tgt, rx846_tgt, rx846_off - rx846_start: + length rx875_eos, rx875_tgt + gt rx875_pos, rx875_eos, rx875_done + set rx875_off, 0 + lt rx875_pos, 2, rx875_start + sub rx875_off, rx875_pos, 1 + substr rx875_tgt, rx875_tgt, rx875_off + rx875_start: $I10 = self.'from'() - ne $I10, -1, rxscan849_done - goto rxscan849_scan - rxscan849_loop: - ($P10) = rx846_cur."from"() + ne $I10, -1, rxscan878_done + goto rxscan878_scan + rxscan878_loop: + ($P10) = rx875_cur."from"() inc $P10 - set rx846_pos, $P10 - ge rx846_pos, rx846_eos, rxscan849_done - rxscan849_scan: - set_addr $I10, rxscan849_loop - rx846_cur."!mark_push"(0, rx846_pos, $I10) - rxscan849_done: -.annotate 'line', 405 + set rx875_pos, $P10 + ge rx875_pos, rx875_eos, rxscan878_done + rxscan878_scan: + set_addr $I10, rxscan878_loop + rx875_cur."!mark_push"(0, rx875_pos, $I10) + rxscan878_done: +.annotate 'line', 417 # rx enumcharlist negate=0 zerowidth - ge rx846_pos, rx846_eos, rx846_fail - sub $I10, rx846_pos, rx846_off - substr $S10, rx846_tgt, $I10, 1 + ge rx875_pos, rx875_eos, rx875_fail + sub $I10, rx875_pos, rx875_off + substr $S10, rx875_tgt, $I10, 1 index $I11, "\"", $S10 - lt $I11, 0, rx846_fail + lt $I11, 0, rx875_fail # rx subrule "quote_EXPR" subtype=capture negate= - rx846_cur."!cursor_pos"(rx846_pos) - $P10 = rx846_cur."quote_EXPR"(":qq") - unless $P10, rx846_fail - rx846_cur."!mark_push"(0, -1, 0, $P10) + rx875_cur."!cursor_pos"(rx875_pos) + $P10 = rx875_cur."quote_EXPR"(":qq") + unless $P10, rx875_fail + rx875_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quote_EXPR") - rx846_pos = $P10."pos"() + rx875_pos = $P10."pos"() # rx pass - rx846_cur."!cursor_pass"(rx846_pos, "quote:sym") - rx846_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx846_pos) - .return (rx846_cur) - rx846_fail: -.annotate 'line', 4 - (rx846_rep, rx846_pos, $I10, $P10) = rx846_cur."!mark_fail"(0) - lt rx846_pos, -1, rx846_done - eq rx846_pos, -1, rx846_fail + rx875_cur."!cursor_pass"(rx875_pos, "quote:sym") + rx875_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx875_pos) + .return (rx875_cur) + rx875_fail: +.annotate 'line', 4 + (rx875_rep, rx875_pos, $I10, $P10) = rx875_cur."!mark_fail"(0) + lt rx875_pos, -1, rx875_done + eq rx875_pos, -1, rx875_fail jump $I10 - rx846_done: - rx846_cur."!cursor_fail"() - rx846_cur."!cursor_debug"("FAIL ", "quote:sym") - .return (rx846_cur) + rx875_done: + rx875_cur."!cursor_fail"() + rx875_cur."!cursor_debug"("FAIL ", "quote:sym") + .return (rx875_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__quote:sym" :subid("198_1275511697.61926") :method +.sub "!PREFIX__quote:sym" :subid("207_1275600007.84296") :method .annotate 'line', 4 - new $P848, "ResizablePMCArray" - push $P848, "\"" - .return ($P848) + new $P877, "ResizablePMCArray" + push $P877, "\"" + .return ($P877) .end .namespace ["NQP";"Grammar"] -.sub "quote:sym" :subid("199_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "quote:sym" :subid("208_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx851_tgt - .local int rx851_pos - .local int rx851_off - .local int rx851_eos - .local int rx851_rep - .local pmc rx851_cur - (rx851_cur, rx851_pos, rx851_tgt) = self."!cursor_start"() - rx851_cur."!cursor_debug"("START ", "quote:sym") - .lex unicode:"$\x{a2}", rx851_cur + .local string rx880_tgt + .local int rx880_pos + .local int rx880_off + .local int rx880_eos + .local int rx880_rep + .local pmc rx880_cur + (rx880_cur, rx880_pos, rx880_tgt) = self."!cursor_start"() + rx880_cur."!cursor_debug"("START ", "quote:sym") + .lex unicode:"$\x{a2}", rx880_cur .local pmc match .lex "$/", match - length rx851_eos, rx851_tgt - gt rx851_pos, rx851_eos, rx851_done - set rx851_off, 0 - lt rx851_pos, 2, rx851_start - sub rx851_off, rx851_pos, 1 - substr rx851_tgt, rx851_tgt, rx851_off - rx851_start: + length rx880_eos, rx880_tgt + gt rx880_pos, rx880_eos, rx880_done + set rx880_off, 0 + lt rx880_pos, 2, rx880_start + sub rx880_off, rx880_pos, 1 + substr rx880_tgt, rx880_tgt, rx880_off + rx880_start: $I10 = self.'from'() - ne $I10, -1, rxscan855_done - goto rxscan855_scan - rxscan855_loop: - ($P10) = rx851_cur."from"() + ne $I10, -1, rxscan884_done + goto rxscan884_scan + rxscan884_loop: + ($P10) = rx880_cur."from"() inc $P10 - set rx851_pos, $P10 - ge rx851_pos, rx851_eos, rxscan855_done - rxscan855_scan: - set_addr $I10, rxscan855_loop - rx851_cur."!mark_push"(0, rx851_pos, $I10) - rxscan855_done: -.annotate 'line', 406 + set rx880_pos, $P10 + ge rx880_pos, rx880_eos, rxscan884_done + rxscan884_scan: + set_addr $I10, rxscan884_loop + rx880_cur."!mark_push"(0, rx880_pos, $I10) + rxscan884_done: +.annotate 'line', 418 # rx literal "q" - add $I11, rx851_pos, 1 - gt $I11, rx851_eos, rx851_fail - sub $I11, rx851_pos, rx851_off - substr $S10, rx851_tgt, $I11, 1 - ne $S10, "q", rx851_fail - add rx851_pos, 1 + add $I11, rx880_pos, 1 + gt $I11, rx880_eos, rx880_fail + sub $I11, rx880_pos, rx880_off + substr $S10, rx880_tgt, $I11, 1 + ne $S10, "q", rx880_fail + add rx880_pos, 1 # rxanchor rwb - le rx851_pos, 0, rx851_fail - sub $I10, rx851_pos, rx851_off - is_cclass $I11, 8192, rx851_tgt, $I10 - if $I11, rx851_fail + le rx880_pos, 0, rx880_fail + sub $I10, rx880_pos, rx880_off + is_cclass $I11, 8192, rx880_tgt, $I10 + if $I11, rx880_fail dec $I10 - is_cclass $I11, 8192, rx851_tgt, $I10 - unless $I11, rx851_fail + is_cclass $I11, 8192, rx880_tgt, $I10 + unless $I11, rx880_fail # rx enumcharlist negate=1 zerowidth - ge rx851_pos, rx851_eos, rx851_fail - sub $I10, rx851_pos, rx851_off - substr $S10, rx851_tgt, $I10, 1 + ge rx880_pos, rx880_eos, rx880_fail + sub $I10, rx880_pos, rx880_off + substr $S10, rx880_tgt, $I10, 1 index $I11, "(", $S10 - ge $I11, 0, rx851_fail + ge $I11, 0, rx880_fail # rx subrule "ws" subtype=method negate= - rx851_cur."!cursor_pos"(rx851_pos) - $P10 = rx851_cur."ws"() - unless $P10, rx851_fail - rx851_pos = $P10."pos"() + rx880_cur."!cursor_pos"(rx880_pos) + $P10 = rx880_cur."ws"() + unless $P10, rx880_fail + rx880_pos = $P10."pos"() # rx subrule "quote_EXPR" subtype=capture negate= - rx851_cur."!cursor_pos"(rx851_pos) - $P10 = rx851_cur."quote_EXPR"(":q") - unless $P10, rx851_fail - rx851_cur."!mark_push"(0, -1, 0, $P10) + rx880_cur."!cursor_pos"(rx880_pos) + $P10 = rx880_cur."quote_EXPR"(":q") + unless $P10, rx880_fail + rx880_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quote_EXPR") - rx851_pos = $P10."pos"() + rx880_pos = $P10."pos"() # rx pass - rx851_cur."!cursor_pass"(rx851_pos, "quote:sym") - rx851_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx851_pos) - .return (rx851_cur) - rx851_fail: -.annotate 'line', 4 - (rx851_rep, rx851_pos, $I10, $P10) = rx851_cur."!mark_fail"(0) - lt rx851_pos, -1, rx851_done - eq rx851_pos, -1, rx851_fail + rx880_cur."!cursor_pass"(rx880_pos, "quote:sym") + rx880_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx880_pos) + .return (rx880_cur) + rx880_fail: +.annotate 'line', 4 + (rx880_rep, rx880_pos, $I10, $P10) = rx880_cur."!mark_fail"(0) + lt rx880_pos, -1, rx880_done + eq rx880_pos, -1, rx880_fail jump $I10 - rx851_done: - rx851_cur."!cursor_fail"() - rx851_cur."!cursor_debug"("FAIL ", "quote:sym") - .return (rx851_cur) + rx880_done: + rx880_cur."!cursor_fail"() + rx880_cur."!cursor_debug"("FAIL ", "quote:sym") + .return (rx880_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__quote:sym" :subid("200_1275511697.61926") :method +.sub "!PREFIX__quote:sym" :subid("209_1275600007.84296") :method .annotate 'line', 4 - $P853 = self."!PREFIX__!subrule"("", "q") - new $P854, "ResizablePMCArray" - push $P854, $P853 - .return ($P854) + $P882 = self."!PREFIX__!subrule"("", "q") + new $P883, "ResizablePMCArray" + push $P883, $P882 + .return ($P883) .end .namespace ["NQP";"Grammar"] -.sub "quote:sym" :subid("201_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "quote:sym" :subid("210_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx857_tgt - .local int rx857_pos - .local int rx857_off - .local int rx857_eos - .local int rx857_rep - .local pmc rx857_cur - (rx857_cur, rx857_pos, rx857_tgt) = self."!cursor_start"() - rx857_cur."!cursor_debug"("START ", "quote:sym") - .lex unicode:"$\x{a2}", rx857_cur + .local string rx886_tgt + .local int rx886_pos + .local int rx886_off + .local int rx886_eos + .local int rx886_rep + .local pmc rx886_cur + (rx886_cur, rx886_pos, rx886_tgt) = self."!cursor_start"() + rx886_cur."!cursor_debug"("START ", "quote:sym") + .lex unicode:"$\x{a2}", rx886_cur .local pmc match .lex "$/", match - length rx857_eos, rx857_tgt - gt rx857_pos, rx857_eos, rx857_done - set rx857_off, 0 - lt rx857_pos, 2, rx857_start - sub rx857_off, rx857_pos, 1 - substr rx857_tgt, rx857_tgt, rx857_off - rx857_start: + length rx886_eos, rx886_tgt + gt rx886_pos, rx886_eos, rx886_done + set rx886_off, 0 + lt rx886_pos, 2, rx886_start + sub rx886_off, rx886_pos, 1 + substr rx886_tgt, rx886_tgt, rx886_off + rx886_start: $I10 = self.'from'() - ne $I10, -1, rxscan861_done - goto rxscan861_scan - rxscan861_loop: - ($P10) = rx857_cur."from"() + ne $I10, -1, rxscan890_done + goto rxscan890_scan + rxscan890_loop: + ($P10) = rx886_cur."from"() inc $P10 - set rx857_pos, $P10 - ge rx857_pos, rx857_eos, rxscan861_done - rxscan861_scan: - set_addr $I10, rxscan861_loop - rx857_cur."!mark_push"(0, rx857_pos, $I10) - rxscan861_done: -.annotate 'line', 407 + set rx886_pos, $P10 + ge rx886_pos, rx886_eos, rxscan890_done + rxscan890_scan: + set_addr $I10, rxscan890_loop + rx886_cur."!mark_push"(0, rx886_pos, $I10) + rxscan890_done: +.annotate 'line', 419 # rx literal "qq" - add $I11, rx857_pos, 2 - gt $I11, rx857_eos, rx857_fail - sub $I11, rx857_pos, rx857_off - substr $S10, rx857_tgt, $I11, 2 - ne $S10, "qq", rx857_fail - add rx857_pos, 2 + add $I11, rx886_pos, 2 + gt $I11, rx886_eos, rx886_fail + sub $I11, rx886_pos, rx886_off + substr $S10, rx886_tgt, $I11, 2 + ne $S10, "qq", rx886_fail + add rx886_pos, 2 # rxanchor rwb - le rx857_pos, 0, rx857_fail - sub $I10, rx857_pos, rx857_off - is_cclass $I11, 8192, rx857_tgt, $I10 - if $I11, rx857_fail + le rx886_pos, 0, rx886_fail + sub $I10, rx886_pos, rx886_off + is_cclass $I11, 8192, rx886_tgt, $I10 + if $I11, rx886_fail dec $I10 - is_cclass $I11, 8192, rx857_tgt, $I10 - unless $I11, rx857_fail + is_cclass $I11, 8192, rx886_tgt, $I10 + unless $I11, rx886_fail # rx enumcharlist negate=1 zerowidth - ge rx857_pos, rx857_eos, rx857_fail - sub $I10, rx857_pos, rx857_off - substr $S10, rx857_tgt, $I10, 1 + ge rx886_pos, rx886_eos, rx886_fail + sub $I10, rx886_pos, rx886_off + substr $S10, rx886_tgt, $I10, 1 index $I11, "(", $S10 - ge $I11, 0, rx857_fail + ge $I11, 0, rx886_fail # rx subrule "ws" subtype=method negate= - rx857_cur."!cursor_pos"(rx857_pos) - $P10 = rx857_cur."ws"() - unless $P10, rx857_fail - rx857_pos = $P10."pos"() + rx886_cur."!cursor_pos"(rx886_pos) + $P10 = rx886_cur."ws"() + unless $P10, rx886_fail + rx886_pos = $P10."pos"() # rx subrule "quote_EXPR" subtype=capture negate= - rx857_cur."!cursor_pos"(rx857_pos) - $P10 = rx857_cur."quote_EXPR"(":qq") - unless $P10, rx857_fail - rx857_cur."!mark_push"(0, -1, 0, $P10) + rx886_cur."!cursor_pos"(rx886_pos) + $P10 = rx886_cur."quote_EXPR"(":qq") + unless $P10, rx886_fail + rx886_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quote_EXPR") - rx857_pos = $P10."pos"() + rx886_pos = $P10."pos"() # rx pass - rx857_cur."!cursor_pass"(rx857_pos, "quote:sym") - rx857_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx857_pos) - .return (rx857_cur) - rx857_fail: + rx886_cur."!cursor_pass"(rx886_pos, "quote:sym") + rx886_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx886_pos) + .return (rx886_cur) + rx886_fail: .annotate 'line', 4 - (rx857_rep, rx857_pos, $I10, $P10) = rx857_cur."!mark_fail"(0) - lt rx857_pos, -1, rx857_done - eq rx857_pos, -1, rx857_fail + (rx886_rep, rx886_pos, $I10, $P10) = rx886_cur."!mark_fail"(0) + lt rx886_pos, -1, rx886_done + eq rx886_pos, -1, rx886_fail jump $I10 - rx857_done: - rx857_cur."!cursor_fail"() - rx857_cur."!cursor_debug"("FAIL ", "quote:sym") - .return (rx857_cur) + rx886_done: + rx886_cur."!cursor_fail"() + rx886_cur."!cursor_debug"("FAIL ", "quote:sym") + .return (rx886_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__quote:sym" :subid("202_1275511697.61926") :method +.sub "!PREFIX__quote:sym" :subid("211_1275600007.84296") :method .annotate 'line', 4 - $P859 = self."!PREFIX__!subrule"("", "qq") - new $P860, "ResizablePMCArray" - push $P860, $P859 - .return ($P860) + $P888 = self."!PREFIX__!subrule"("", "qq") + new $P889, "ResizablePMCArray" + push $P889, $P888 + .return ($P889) .end .namespace ["NQP";"Grammar"] -.sub "quote:sym" :subid("203_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "quote:sym" :subid("212_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx863_tgt - .local int rx863_pos - .local int rx863_off - .local int rx863_eos - .local int rx863_rep - .local pmc rx863_cur - (rx863_cur, rx863_pos, rx863_tgt) = self."!cursor_start"() - rx863_cur."!cursor_debug"("START ", "quote:sym") - .lex unicode:"$\x{a2}", rx863_cur + .local string rx892_tgt + .local int rx892_pos + .local int rx892_off + .local int rx892_eos + .local int rx892_rep + .local pmc rx892_cur + (rx892_cur, rx892_pos, rx892_tgt) = self."!cursor_start"() + rx892_cur."!cursor_debug"("START ", "quote:sym") + .lex unicode:"$\x{a2}", rx892_cur .local pmc match .lex "$/", match - length rx863_eos, rx863_tgt - gt rx863_pos, rx863_eos, rx863_done - set rx863_off, 0 - lt rx863_pos, 2, rx863_start - sub rx863_off, rx863_pos, 1 - substr rx863_tgt, rx863_tgt, rx863_off - rx863_start: + length rx892_eos, rx892_tgt + gt rx892_pos, rx892_eos, rx892_done + set rx892_off, 0 + lt rx892_pos, 2, rx892_start + sub rx892_off, rx892_pos, 1 + substr rx892_tgt, rx892_tgt, rx892_off + rx892_start: $I10 = self.'from'() - ne $I10, -1, rxscan867_done - goto rxscan867_scan - rxscan867_loop: - ($P10) = rx863_cur."from"() + ne $I10, -1, rxscan896_done + goto rxscan896_scan + rxscan896_loop: + ($P10) = rx892_cur."from"() inc $P10 - set rx863_pos, $P10 - ge rx863_pos, rx863_eos, rxscan867_done - rxscan867_scan: - set_addr $I10, rxscan867_loop - rx863_cur."!mark_push"(0, rx863_pos, $I10) - rxscan867_done: -.annotate 'line', 408 + set rx892_pos, $P10 + ge rx892_pos, rx892_eos, rxscan896_done + rxscan896_scan: + set_addr $I10, rxscan896_loop + rx892_cur."!mark_push"(0, rx892_pos, $I10) + rxscan896_done: +.annotate 'line', 420 # rx literal "Q" - add $I11, rx863_pos, 1 - gt $I11, rx863_eos, rx863_fail - sub $I11, rx863_pos, rx863_off - substr $S10, rx863_tgt, $I11, 1 - ne $S10, "Q", rx863_fail - add rx863_pos, 1 + add $I11, rx892_pos, 1 + gt $I11, rx892_eos, rx892_fail + sub $I11, rx892_pos, rx892_off + substr $S10, rx892_tgt, $I11, 1 + ne $S10, "Q", rx892_fail + add rx892_pos, 1 # rxanchor rwb - le rx863_pos, 0, rx863_fail - sub $I10, rx863_pos, rx863_off - is_cclass $I11, 8192, rx863_tgt, $I10 - if $I11, rx863_fail + le rx892_pos, 0, rx892_fail + sub $I10, rx892_pos, rx892_off + is_cclass $I11, 8192, rx892_tgt, $I10 + if $I11, rx892_fail dec $I10 - is_cclass $I11, 8192, rx863_tgt, $I10 - unless $I11, rx863_fail + is_cclass $I11, 8192, rx892_tgt, $I10 + unless $I11, rx892_fail # rx enumcharlist negate=1 zerowidth - ge rx863_pos, rx863_eos, rx863_fail - sub $I10, rx863_pos, rx863_off - substr $S10, rx863_tgt, $I10, 1 + ge rx892_pos, rx892_eos, rx892_fail + sub $I10, rx892_pos, rx892_off + substr $S10, rx892_tgt, $I10, 1 index $I11, "(", $S10 - ge $I11, 0, rx863_fail + ge $I11, 0, rx892_fail # rx subrule "ws" subtype=method negate= - rx863_cur."!cursor_pos"(rx863_pos) - $P10 = rx863_cur."ws"() - unless $P10, rx863_fail - rx863_pos = $P10."pos"() + rx892_cur."!cursor_pos"(rx892_pos) + $P10 = rx892_cur."ws"() + unless $P10, rx892_fail + rx892_pos = $P10."pos"() # rx subrule "quote_EXPR" subtype=capture negate= - rx863_cur."!cursor_pos"(rx863_pos) - $P10 = rx863_cur."quote_EXPR"() - unless $P10, rx863_fail - rx863_cur."!mark_push"(0, -1, 0, $P10) + rx892_cur."!cursor_pos"(rx892_pos) + $P10 = rx892_cur."quote_EXPR"() + unless $P10, rx892_fail + rx892_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quote_EXPR") - rx863_pos = $P10."pos"() + rx892_pos = $P10."pos"() # rx pass - rx863_cur."!cursor_pass"(rx863_pos, "quote:sym") - rx863_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx863_pos) - .return (rx863_cur) - rx863_fail: -.annotate 'line', 4 - (rx863_rep, rx863_pos, $I10, $P10) = rx863_cur."!mark_fail"(0) - lt rx863_pos, -1, rx863_done - eq rx863_pos, -1, rx863_fail + rx892_cur."!cursor_pass"(rx892_pos, "quote:sym") + rx892_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx892_pos) + .return (rx892_cur) + rx892_fail: +.annotate 'line', 4 + (rx892_rep, rx892_pos, $I10, $P10) = rx892_cur."!mark_fail"(0) + lt rx892_pos, -1, rx892_done + eq rx892_pos, -1, rx892_fail jump $I10 - rx863_done: - rx863_cur."!cursor_fail"() - rx863_cur."!cursor_debug"("FAIL ", "quote:sym") - .return (rx863_cur) + rx892_done: + rx892_cur."!cursor_fail"() + rx892_cur."!cursor_debug"("FAIL ", "quote:sym") + .return (rx892_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__quote:sym" :subid("204_1275511697.61926") :method +.sub "!PREFIX__quote:sym" :subid("213_1275600007.84296") :method .annotate 'line', 4 - $P865 = self."!PREFIX__!subrule"("", "Q") - new $P866, "ResizablePMCArray" - push $P866, $P865 - .return ($P866) + $P894 = self."!PREFIX__!subrule"("", "Q") + new $P895, "ResizablePMCArray" + push $P895, $P894 + .return ($P895) .end .namespace ["NQP";"Grammar"] -.sub "quote:sym" :subid("205_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "quote:sym" :subid("214_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx869_tgt - .local int rx869_pos - .local int rx869_off - .local int rx869_eos - .local int rx869_rep - .local pmc rx869_cur - (rx869_cur, rx869_pos, rx869_tgt) = self."!cursor_start"() - rx869_cur."!cursor_debug"("START ", "quote:sym") - .lex unicode:"$\x{a2}", rx869_cur + .local string rx898_tgt + .local int rx898_pos + .local int rx898_off + .local int rx898_eos + .local int rx898_rep + .local pmc rx898_cur + (rx898_cur, rx898_pos, rx898_tgt) = self."!cursor_start"() + rx898_cur."!cursor_debug"("START ", "quote:sym") + .lex unicode:"$\x{a2}", rx898_cur .local pmc match .lex "$/", match - length rx869_eos, rx869_tgt - gt rx869_pos, rx869_eos, rx869_done - set rx869_off, 0 - lt rx869_pos, 2, rx869_start - sub rx869_off, rx869_pos, 1 - substr rx869_tgt, rx869_tgt, rx869_off - rx869_start: + length rx898_eos, rx898_tgt + gt rx898_pos, rx898_eos, rx898_done + set rx898_off, 0 + lt rx898_pos, 2, rx898_start + sub rx898_off, rx898_pos, 1 + substr rx898_tgt, rx898_tgt, rx898_off + rx898_start: $I10 = self.'from'() - ne $I10, -1, rxscan873_done - goto rxscan873_scan - rxscan873_loop: - ($P10) = rx869_cur."from"() + ne $I10, -1, rxscan902_done + goto rxscan902_scan + rxscan902_loop: + ($P10) = rx898_cur."from"() inc $P10 - set rx869_pos, $P10 - ge rx869_pos, rx869_eos, rxscan873_done - rxscan873_scan: - set_addr $I10, rxscan873_loop - rx869_cur."!mark_push"(0, rx869_pos, $I10) - rxscan873_done: -.annotate 'line', 409 + set rx898_pos, $P10 + ge rx898_pos, rx898_eos, rxscan902_done + rxscan902_scan: + set_addr $I10, rxscan902_loop + rx898_cur."!mark_push"(0, rx898_pos, $I10) + rxscan902_done: +.annotate 'line', 421 # rx literal "Q:PIR" - add $I11, rx869_pos, 5 - gt $I11, rx869_eos, rx869_fail - sub $I11, rx869_pos, rx869_off - substr $S10, rx869_tgt, $I11, 5 - ne $S10, "Q:PIR", rx869_fail - add rx869_pos, 5 + add $I11, rx898_pos, 5 + gt $I11, rx898_eos, rx898_fail + sub $I11, rx898_pos, rx898_off + substr $S10, rx898_tgt, $I11, 5 + ne $S10, "Q:PIR", rx898_fail + add rx898_pos, 5 # rx subrule "ws" subtype=method negate= - rx869_cur."!cursor_pos"(rx869_pos) - $P10 = rx869_cur."ws"() - unless $P10, rx869_fail - rx869_pos = $P10."pos"() + rx898_cur."!cursor_pos"(rx898_pos) + $P10 = rx898_cur."ws"() + unless $P10, rx898_fail + rx898_pos = $P10."pos"() # rx subrule "quote_EXPR" subtype=capture negate= - rx869_cur."!cursor_pos"(rx869_pos) - $P10 = rx869_cur."quote_EXPR"() - unless $P10, rx869_fail - rx869_cur."!mark_push"(0, -1, 0, $P10) + rx898_cur."!cursor_pos"(rx898_pos) + $P10 = rx898_cur."quote_EXPR"() + unless $P10, rx898_fail + rx898_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quote_EXPR") - rx869_pos = $P10."pos"() + rx898_pos = $P10."pos"() # rx pass - rx869_cur."!cursor_pass"(rx869_pos, "quote:sym") - rx869_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx869_pos) - .return (rx869_cur) - rx869_fail: -.annotate 'line', 4 - (rx869_rep, rx869_pos, $I10, $P10) = rx869_cur."!mark_fail"(0) - lt rx869_pos, -1, rx869_done - eq rx869_pos, -1, rx869_fail + rx898_cur."!cursor_pass"(rx898_pos, "quote:sym") + rx898_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx898_pos) + .return (rx898_cur) + rx898_fail: +.annotate 'line', 4 + (rx898_rep, rx898_pos, $I10, $P10) = rx898_cur."!mark_fail"(0) + lt rx898_pos, -1, rx898_done + eq rx898_pos, -1, rx898_fail jump $I10 - rx869_done: - rx869_cur."!cursor_fail"() - rx869_cur."!cursor_debug"("FAIL ", "quote:sym") - .return (rx869_cur) + rx898_done: + rx898_cur."!cursor_fail"() + rx898_cur."!cursor_debug"("FAIL ", "quote:sym") + .return (rx898_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__quote:sym" :subid("206_1275511697.61926") :method +.sub "!PREFIX__quote:sym" :subid("215_1275600007.84296") :method .annotate 'line', 4 - $P871 = self."!PREFIX__!subrule"("", "Q:PIR") - new $P872, "ResizablePMCArray" - push $P872, $P871 - .return ($P872) + $P900 = self."!PREFIX__!subrule"("", "Q:PIR") + new $P901, "ResizablePMCArray" + push $P901, $P900 + .return ($P901) .end .namespace ["NQP";"Grammar"] -.sub "quote:sym" :subid("207_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "quote:sym" :subid("216_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx875_tgt - .local int rx875_pos - .local int rx875_off - .local int rx875_eos - .local int rx875_rep - .local pmc rx875_cur - (rx875_cur, rx875_pos, rx875_tgt) = self."!cursor_start"() - rx875_cur."!cursor_debug"("START ", "quote:sym") - .lex unicode:"$\x{a2}", rx875_cur + .local string rx904_tgt + .local int rx904_pos + .local int rx904_off + .local int rx904_eos + .local int rx904_rep + .local pmc rx904_cur + (rx904_cur, rx904_pos, rx904_tgt) = self."!cursor_start"() + rx904_cur."!cursor_debug"("START ", "quote:sym") + .lex unicode:"$\x{a2}", rx904_cur .local pmc match .lex "$/", match - length rx875_eos, rx875_tgt - gt rx875_pos, rx875_eos, rx875_done - set rx875_off, 0 - lt rx875_pos, 2, rx875_start - sub rx875_off, rx875_pos, 1 - substr rx875_tgt, rx875_tgt, rx875_off - rx875_start: + length rx904_eos, rx904_tgt + gt rx904_pos, rx904_eos, rx904_done + set rx904_off, 0 + lt rx904_pos, 2, rx904_start + sub rx904_off, rx904_pos, 1 + substr rx904_tgt, rx904_tgt, rx904_off + rx904_start: $I10 = self.'from'() - ne $I10, -1, rxscan879_done - goto rxscan879_scan - rxscan879_loop: - ($P10) = rx875_cur."from"() + ne $I10, -1, rxscan908_done + goto rxscan908_scan + rxscan908_loop: + ($P10) = rx904_cur."from"() inc $P10 - set rx875_pos, $P10 - ge rx875_pos, rx875_eos, rxscan879_done - rxscan879_scan: - set_addr $I10, rxscan879_loop - rx875_cur."!mark_push"(0, rx875_pos, $I10) - rxscan879_done: -.annotate 'line', 411 + set rx904_pos, $P10 + ge rx904_pos, rx904_eos, rxscan908_done + rxscan908_scan: + set_addr $I10, rxscan908_loop + rx904_cur."!mark_push"(0, rx904_pos, $I10) + rxscan908_done: +.annotate 'line', 423 # rx literal "/" - add $I11, rx875_pos, 1 - gt $I11, rx875_eos, rx875_fail - sub $I11, rx875_pos, rx875_off - substr $S10, rx875_tgt, $I11, 1 - ne $S10, "/", rx875_fail - add rx875_pos, 1 -.annotate 'line', 412 + add $I11, rx904_pos, 1 + gt $I11, rx904_eos, rx904_fail + sub $I11, rx904_pos, rx904_off + substr $S10, rx904_tgt, $I11, 1 + ne $S10, "/", rx904_fail + add rx904_pos, 1 +.annotate 'line', 424 # rx subrule "newpad" subtype=method negate= - rx875_cur."!cursor_pos"(rx875_pos) - $P10 = rx875_cur."newpad"() - unless $P10, rx875_fail - rx875_pos = $P10."pos"() -.annotate 'line', 413 + rx904_cur."!cursor_pos"(rx904_pos) + $P10 = rx904_cur."newpad"() + unless $P10, rx904_fail + rx904_pos = $P10."pos"() +.annotate 'line', 425 # rx reduce name="quote:sym" key="open" - rx875_cur."!cursor_pos"(rx875_pos) - rx875_cur."!reduce"("quote:sym", "open") -.annotate 'line', 414 + rx904_cur."!cursor_pos"(rx904_pos) + rx904_cur."!reduce"("quote:sym", "open") +.annotate 'line', 426 # rx subrule "LANG" subtype=capture negate= - rx875_cur."!cursor_pos"(rx875_pos) - $P10 = rx875_cur."LANG"("Regex", "nibbler") - unless $P10, rx875_fail - rx875_cur."!mark_push"(0, -1, 0, $P10) + rx904_cur."!cursor_pos"(rx904_pos) + $P10 = rx904_cur."LANG"("Regex", "nibbler") + unless $P10, rx904_fail + rx904_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("p6regex") - rx875_pos = $P10."pos"() -.annotate 'line', 415 + rx904_pos = $P10."pos"() +.annotate 'line', 427 # rx literal "/" - add $I11, rx875_pos, 1 - gt $I11, rx875_eos, rx875_fail - sub $I11, rx875_pos, rx875_off - substr $S10, rx875_tgt, $I11, 1 - ne $S10, "/", rx875_fail - add rx875_pos, 1 -.annotate 'line', 410 + add $I11, rx904_pos, 1 + gt $I11, rx904_eos, rx904_fail + sub $I11, rx904_pos, rx904_off + substr $S10, rx904_tgt, $I11, 1 + ne $S10, "/", rx904_fail + add rx904_pos, 1 +.annotate 'line', 422 # rx pass - rx875_cur."!cursor_pass"(rx875_pos, "quote:sym") - rx875_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx875_pos) - .return (rx875_cur) - rx875_fail: + rx904_cur."!cursor_pass"(rx904_pos, "quote:sym") + rx904_cur."!cursor_debug"("PASS ", "quote:sym", " at pos=", rx904_pos) + .return (rx904_cur) + rx904_fail: .annotate 'line', 4 - (rx875_rep, rx875_pos, $I10, $P10) = rx875_cur."!mark_fail"(0) - lt rx875_pos, -1, rx875_done - eq rx875_pos, -1, rx875_fail + (rx904_rep, rx904_pos, $I10, $P10) = rx904_cur."!mark_fail"(0) + lt rx904_pos, -1, rx904_done + eq rx904_pos, -1, rx904_fail jump $I10 - rx875_done: - rx875_cur."!cursor_fail"() - rx875_cur."!cursor_debug"("FAIL ", "quote:sym") - .return (rx875_cur) + rx904_done: + rx904_cur."!cursor_fail"() + rx904_cur."!cursor_debug"("FAIL ", "quote:sym") + .return (rx904_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__quote:sym" :subid("208_1275511697.61926") :method +.sub "!PREFIX__quote:sym" :subid("217_1275600007.84296") :method .annotate 'line', 4 - $P877 = self."!PREFIX__!subrule"("", "/") - new $P878, "ResizablePMCArray" - push $P878, $P877 - .return ($P878) + $P906 = self."!PREFIX__!subrule"("", "/") + new $P907, "ResizablePMCArray" + push $P907, $P906 + .return ($P907) .end .namespace ["NQP";"Grammar"] -.sub "quote_escape:sym<$>" :subid("209_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "quote_escape:sym<$>" :subid("218_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx881_tgt - .local int rx881_pos - .local int rx881_off - .local int rx881_eos - .local int rx881_rep - .local pmc rx881_cur - (rx881_cur, rx881_pos, rx881_tgt) = self."!cursor_start"() - rx881_cur."!cursor_debug"("START ", "quote_escape:sym<$>") - .lex unicode:"$\x{a2}", rx881_cur + .local string rx910_tgt + .local int rx910_pos + .local int rx910_off + .local int rx910_eos + .local int rx910_rep + .local pmc rx910_cur + (rx910_cur, rx910_pos, rx910_tgt) = self."!cursor_start"() + rx910_cur."!cursor_debug"("START ", "quote_escape:sym<$>") + .lex unicode:"$\x{a2}", rx910_cur .local pmc match .lex "$/", match - length rx881_eos, rx881_tgt - gt rx881_pos, rx881_eos, rx881_done - set rx881_off, 0 - lt rx881_pos, 2, rx881_start - sub rx881_off, rx881_pos, 1 - substr rx881_tgt, rx881_tgt, rx881_off - rx881_start: + length rx910_eos, rx910_tgt + gt rx910_pos, rx910_eos, rx910_done + set rx910_off, 0 + lt rx910_pos, 2, rx910_start + sub rx910_off, rx910_pos, 1 + substr rx910_tgt, rx910_tgt, rx910_off + rx910_start: $I10 = self.'from'() - ne $I10, -1, rxscan884_done - goto rxscan884_scan - rxscan884_loop: - ($P10) = rx881_cur."from"() + ne $I10, -1, rxscan913_done + goto rxscan913_scan + rxscan913_loop: + ($P10) = rx910_cur."from"() inc $P10 - set rx881_pos, $P10 - ge rx881_pos, rx881_eos, rxscan884_done - rxscan884_scan: - set_addr $I10, rxscan884_loop - rx881_cur."!mark_push"(0, rx881_pos, $I10) - rxscan884_done: -.annotate 'line', 418 + set rx910_pos, $P10 + ge rx910_pos, rx910_eos, rxscan913_done + rxscan913_scan: + set_addr $I10, rxscan913_loop + rx910_cur."!mark_push"(0, rx910_pos, $I10) + rxscan913_done: +.annotate 'line', 430 # rx enumcharlist negate=0 zerowidth - ge rx881_pos, rx881_eos, rx881_fail - sub $I10, rx881_pos, rx881_off - substr $S10, rx881_tgt, $I10, 1 + ge rx910_pos, rx910_eos, rx910_fail + sub $I10, rx910_pos, rx910_off + substr $S10, rx910_tgt, $I10, 1 index $I11, "$", $S10 - lt $I11, 0, rx881_fail + lt $I11, 0, rx910_fail # rx subrule "quotemod_check" subtype=zerowidth negate= - rx881_cur."!cursor_pos"(rx881_pos) - $P10 = rx881_cur."quotemod_check"("s") - unless $P10, rx881_fail + rx910_cur."!cursor_pos"(rx910_pos) + $P10 = rx910_cur."quotemod_check"("s") + unless $P10, rx910_fail # rx subrule "variable" subtype=capture negate= - rx881_cur."!cursor_pos"(rx881_pos) - $P10 = rx881_cur."variable"() - unless $P10, rx881_fail - rx881_cur."!mark_push"(0, -1, 0, $P10) + rx910_cur."!cursor_pos"(rx910_pos) + $P10 = rx910_cur."variable"() + unless $P10, rx910_fail + rx910_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("variable") - rx881_pos = $P10."pos"() + rx910_pos = $P10."pos"() # rx pass - rx881_cur."!cursor_pass"(rx881_pos, "quote_escape:sym<$>") - rx881_cur."!cursor_debug"("PASS ", "quote_escape:sym<$>", " at pos=", rx881_pos) - .return (rx881_cur) - rx881_fail: -.annotate 'line', 4 - (rx881_rep, rx881_pos, $I10, $P10) = rx881_cur."!mark_fail"(0) - lt rx881_pos, -1, rx881_done - eq rx881_pos, -1, rx881_fail + rx910_cur."!cursor_pass"(rx910_pos, "quote_escape:sym<$>") + rx910_cur."!cursor_debug"("PASS ", "quote_escape:sym<$>", " at pos=", rx910_pos) + .return (rx910_cur) + rx910_fail: +.annotate 'line', 4 + (rx910_rep, rx910_pos, $I10, $P10) = rx910_cur."!mark_fail"(0) + lt rx910_pos, -1, rx910_done + eq rx910_pos, -1, rx910_fail jump $I10 - rx881_done: - rx881_cur."!cursor_fail"() - rx881_cur."!cursor_debug"("FAIL ", "quote_escape:sym<$>") - .return (rx881_cur) + rx910_done: + rx910_cur."!cursor_fail"() + rx910_cur."!cursor_debug"("FAIL ", "quote_escape:sym<$>") + .return (rx910_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__quote_escape:sym<$>" :subid("210_1275511697.61926") :method +.sub "!PREFIX__quote_escape:sym<$>" :subid("219_1275600007.84296") :method .annotate 'line', 4 - new $P883, "ResizablePMCArray" - push $P883, "$" - .return ($P883) + new $P912, "ResizablePMCArray" + push $P912, "$" + .return ($P912) .end .namespace ["NQP";"Grammar"] -.sub "quote_escape:sym<{ }>" :subid("211_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "quote_escape:sym<{ }>" :subid("220_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx886_tgt - .local int rx886_pos - .local int rx886_off - .local int rx886_eos - .local int rx886_rep - .local pmc rx886_cur - (rx886_cur, rx886_pos, rx886_tgt) = self."!cursor_start"() - rx886_cur."!cursor_debug"("START ", "quote_escape:sym<{ }>") - .lex unicode:"$\x{a2}", rx886_cur + .local string rx915_tgt + .local int rx915_pos + .local int rx915_off + .local int rx915_eos + .local int rx915_rep + .local pmc rx915_cur + (rx915_cur, rx915_pos, rx915_tgt) = self."!cursor_start"() + rx915_cur."!cursor_debug"("START ", "quote_escape:sym<{ }>") + .lex unicode:"$\x{a2}", rx915_cur .local pmc match .lex "$/", match - length rx886_eos, rx886_tgt - gt rx886_pos, rx886_eos, rx886_done - set rx886_off, 0 - lt rx886_pos, 2, rx886_start - sub rx886_off, rx886_pos, 1 - substr rx886_tgt, rx886_tgt, rx886_off - rx886_start: + length rx915_eos, rx915_tgt + gt rx915_pos, rx915_eos, rx915_done + set rx915_off, 0 + lt rx915_pos, 2, rx915_start + sub rx915_off, rx915_pos, 1 + substr rx915_tgt, rx915_tgt, rx915_off + rx915_start: $I10 = self.'from'() - ne $I10, -1, rxscan889_done - goto rxscan889_scan - rxscan889_loop: - ($P10) = rx886_cur."from"() + ne $I10, -1, rxscan918_done + goto rxscan918_scan + rxscan918_loop: + ($P10) = rx915_cur."from"() inc $P10 - set rx886_pos, $P10 - ge rx886_pos, rx886_eos, rxscan889_done - rxscan889_scan: - set_addr $I10, rxscan889_loop - rx886_cur."!mark_push"(0, rx886_pos, $I10) - rxscan889_done: -.annotate 'line', 419 + set rx915_pos, $P10 + ge rx915_pos, rx915_eos, rxscan918_done + rxscan918_scan: + set_addr $I10, rxscan918_loop + rx915_cur."!mark_push"(0, rx915_pos, $I10) + rxscan918_done: +.annotate 'line', 431 # rx enumcharlist negate=0 zerowidth - ge rx886_pos, rx886_eos, rx886_fail - sub $I10, rx886_pos, rx886_off - substr $S10, rx886_tgt, $I10, 1 + ge rx915_pos, rx915_eos, rx915_fail + sub $I10, rx915_pos, rx915_off + substr $S10, rx915_tgt, $I10, 1 index $I11, "{", $S10 - lt $I11, 0, rx886_fail + lt $I11, 0, rx915_fail # rx subrule "quotemod_check" subtype=zerowidth negate= - rx886_cur."!cursor_pos"(rx886_pos) - $P10 = rx886_cur."quotemod_check"("c") - unless $P10, rx886_fail + rx915_cur."!cursor_pos"(rx915_pos) + $P10 = rx915_cur."quotemod_check"("c") + unless $P10, rx915_fail # rx subrule "block" subtype=capture negate= - rx886_cur."!cursor_pos"(rx886_pos) - $P10 = rx886_cur."block"() - unless $P10, rx886_fail - rx886_cur."!mark_push"(0, -1, 0, $P10) + rx915_cur."!cursor_pos"(rx915_pos) + $P10 = rx915_cur."block"() + unless $P10, rx915_fail + rx915_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("block") - rx886_pos = $P10."pos"() + rx915_pos = $P10."pos"() # rx pass - rx886_cur."!cursor_pass"(rx886_pos, "quote_escape:sym<{ }>") - rx886_cur."!cursor_debug"("PASS ", "quote_escape:sym<{ }>", " at pos=", rx886_pos) - .return (rx886_cur) - rx886_fail: -.annotate 'line', 4 - (rx886_rep, rx886_pos, $I10, $P10) = rx886_cur."!mark_fail"(0) - lt rx886_pos, -1, rx886_done - eq rx886_pos, -1, rx886_fail + rx915_cur."!cursor_pass"(rx915_pos, "quote_escape:sym<{ }>") + rx915_cur."!cursor_debug"("PASS ", "quote_escape:sym<{ }>", " at pos=", rx915_pos) + .return (rx915_cur) + rx915_fail: +.annotate 'line', 4 + (rx915_rep, rx915_pos, $I10, $P10) = rx915_cur."!mark_fail"(0) + lt rx915_pos, -1, rx915_done + eq rx915_pos, -1, rx915_fail jump $I10 - rx886_done: - rx886_cur."!cursor_fail"() - rx886_cur."!cursor_debug"("FAIL ", "quote_escape:sym<{ }>") - .return (rx886_cur) + rx915_done: + rx915_cur."!cursor_fail"() + rx915_cur."!cursor_debug"("FAIL ", "quote_escape:sym<{ }>") + .return (rx915_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__quote_escape:sym<{ }>" :subid("212_1275511697.61926") :method +.sub "!PREFIX__quote_escape:sym<{ }>" :subid("221_1275600007.84296") :method .annotate 'line', 4 - new $P888, "ResizablePMCArray" - push $P888, "{" - .return ($P888) + new $P917, "ResizablePMCArray" + push $P917, "{" + .return ($P917) .end .namespace ["NQP";"Grammar"] -.sub "quote_escape:sym" :subid("213_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "quote_escape:sym" :subid("222_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx891_tgt - .local int rx891_pos - .local int rx891_off - .local int rx891_eos - .local int rx891_rep - .local pmc rx891_cur - (rx891_cur, rx891_pos, rx891_tgt) = self."!cursor_start"() - rx891_cur."!cursor_debug"("START ", "quote_escape:sym") - .lex unicode:"$\x{a2}", rx891_cur + .local string rx920_tgt + .local int rx920_pos + .local int rx920_off + .local int rx920_eos + .local int rx920_rep + .local pmc rx920_cur + (rx920_cur, rx920_pos, rx920_tgt) = self."!cursor_start"() + rx920_cur."!cursor_debug"("START ", "quote_escape:sym") + .lex unicode:"$\x{a2}", rx920_cur .local pmc match .lex "$/", match - length rx891_eos, rx891_tgt - gt rx891_pos, rx891_eos, rx891_done - set rx891_off, 0 - lt rx891_pos, 2, rx891_start - sub rx891_off, rx891_pos, 1 - substr rx891_tgt, rx891_tgt, rx891_off - rx891_start: + length rx920_eos, rx920_tgt + gt rx920_pos, rx920_eos, rx920_done + set rx920_off, 0 + lt rx920_pos, 2, rx920_start + sub rx920_off, rx920_pos, 1 + substr rx920_tgt, rx920_tgt, rx920_off + rx920_start: $I10 = self.'from'() - ne $I10, -1, rxscan894_done - goto rxscan894_scan - rxscan894_loop: - ($P10) = rx891_cur."from"() + ne $I10, -1, rxscan923_done + goto rxscan923_scan + rxscan923_loop: + ($P10) = rx920_cur."from"() inc $P10 - set rx891_pos, $P10 - ge rx891_pos, rx891_eos, rxscan894_done - rxscan894_scan: - set_addr $I10, rxscan894_loop - rx891_cur."!mark_push"(0, rx891_pos, $I10) - rxscan894_done: -.annotate 'line', 420 + set rx920_pos, $P10 + ge rx920_pos, rx920_eos, rxscan923_done + rxscan923_scan: + set_addr $I10, rxscan923_loop + rx920_cur."!mark_push"(0, rx920_pos, $I10) + rxscan923_done: +.annotate 'line', 432 # rx literal "\\e" - add $I11, rx891_pos, 2 - gt $I11, rx891_eos, rx891_fail - sub $I11, rx891_pos, rx891_off - substr $S10, rx891_tgt, $I11, 2 - ne $S10, "\\e", rx891_fail - add rx891_pos, 2 + add $I11, rx920_pos, 2 + gt $I11, rx920_eos, rx920_fail + sub $I11, rx920_pos, rx920_off + substr $S10, rx920_tgt, $I11, 2 + ne $S10, "\\e", rx920_fail + add rx920_pos, 2 # rx subrule "quotemod_check" subtype=zerowidth negate= - rx891_cur."!cursor_pos"(rx891_pos) - $P10 = rx891_cur."quotemod_check"("b") - unless $P10, rx891_fail + rx920_cur."!cursor_pos"(rx920_pos) + $P10 = rx920_cur."quotemod_check"("b") + unless $P10, rx920_fail # rx pass - rx891_cur."!cursor_pass"(rx891_pos, "quote_escape:sym") - rx891_cur."!cursor_debug"("PASS ", "quote_escape:sym", " at pos=", rx891_pos) - .return (rx891_cur) - rx891_fail: -.annotate 'line', 4 - (rx891_rep, rx891_pos, $I10, $P10) = rx891_cur."!mark_fail"(0) - lt rx891_pos, -1, rx891_done - eq rx891_pos, -1, rx891_fail + rx920_cur."!cursor_pass"(rx920_pos, "quote_escape:sym") + rx920_cur."!cursor_debug"("PASS ", "quote_escape:sym", " at pos=", rx920_pos) + .return (rx920_cur) + rx920_fail: +.annotate 'line', 4 + (rx920_rep, rx920_pos, $I10, $P10) = rx920_cur."!mark_fail"(0) + lt rx920_pos, -1, rx920_done + eq rx920_pos, -1, rx920_fail jump $I10 - rx891_done: - rx891_cur."!cursor_fail"() - rx891_cur."!cursor_debug"("FAIL ", "quote_escape:sym") - .return (rx891_cur) + rx920_done: + rx920_cur."!cursor_fail"() + rx920_cur."!cursor_debug"("FAIL ", "quote_escape:sym") + .return (rx920_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__quote_escape:sym" :subid("214_1275511697.61926") :method +.sub "!PREFIX__quote_escape:sym" :subid("223_1275600007.84296") :method .annotate 'line', 4 - new $P893, "ResizablePMCArray" - push $P893, "\\e" - .return ($P893) + new $P922, "ResizablePMCArray" + push $P922, "\\e" + .return ($P922) .end .namespace ["NQP";"Grammar"] -.sub "circumfix:sym<( )>" :subid("215_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "circumfix:sym<( )>" :subid("224_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx896_tgt - .local int rx896_pos - .local int rx896_off - .local int rx896_eos - .local int rx896_rep - .local pmc rx896_cur - (rx896_cur, rx896_pos, rx896_tgt) = self."!cursor_start"() - rx896_cur."!cursor_debug"("START ", "circumfix:sym<( )>") - rx896_cur."!cursor_caparray"("EXPR") - .lex unicode:"$\x{a2}", rx896_cur + .local string rx925_tgt + .local int rx925_pos + .local int rx925_off + .local int rx925_eos + .local int rx925_rep + .local pmc rx925_cur + (rx925_cur, rx925_pos, rx925_tgt) = self."!cursor_start"() + rx925_cur."!cursor_debug"("START ", "circumfix:sym<( )>") + rx925_cur."!cursor_caparray"("EXPR") + .lex unicode:"$\x{a2}", rx925_cur .local pmc match .lex "$/", match - length rx896_eos, rx896_tgt - gt rx896_pos, rx896_eos, rx896_done - set rx896_off, 0 - lt rx896_pos, 2, rx896_start - sub rx896_off, rx896_pos, 1 - substr rx896_tgt, rx896_tgt, rx896_off - rx896_start: + length rx925_eos, rx925_tgt + gt rx925_pos, rx925_eos, rx925_done + set rx925_off, 0 + lt rx925_pos, 2, rx925_start + sub rx925_off, rx925_pos, 1 + substr rx925_tgt, rx925_tgt, rx925_off + rx925_start: $I10 = self.'from'() - ne $I10, -1, rxscan900_done - goto rxscan900_scan - rxscan900_loop: - ($P10) = rx896_cur."from"() + ne $I10, -1, rxscan929_done + goto rxscan929_scan + rxscan929_loop: + ($P10) = rx925_cur."from"() inc $P10 - set rx896_pos, $P10 - ge rx896_pos, rx896_eos, rxscan900_done - rxscan900_scan: - set_addr $I10, rxscan900_loop - rx896_cur."!mark_push"(0, rx896_pos, $I10) - rxscan900_done: -.annotate 'line', 422 + set rx925_pos, $P10 + ge rx925_pos, rx925_eos, rxscan929_done + rxscan929_scan: + set_addr $I10, rxscan929_loop + rx925_cur."!mark_push"(0, rx925_pos, $I10) + rxscan929_done: +.annotate 'line', 434 # rx literal "(" - add $I11, rx896_pos, 1 - gt $I11, rx896_eos, rx896_fail - sub $I11, rx896_pos, rx896_off - substr $S10, rx896_tgt, $I11, 1 - ne $S10, "(", rx896_fail - add rx896_pos, 1 + add $I11, rx925_pos, 1 + gt $I11, rx925_eos, rx925_fail + sub $I11, rx925_pos, rx925_off + substr $S10, rx925_tgt, $I11, 1 + ne $S10, "(", rx925_fail + add rx925_pos, 1 # rx subrule "ws" subtype=method negate= - rx896_cur."!cursor_pos"(rx896_pos) - $P10 = rx896_cur."ws"() - unless $P10, rx896_fail - rx896_pos = $P10."pos"() - # rx rxquantr901 ** 0..1 - set_addr $I902, rxquantr901_done - rx896_cur."!mark_push"(0, rx896_pos, $I902) - rxquantr901_loop: + rx925_cur."!cursor_pos"(rx925_pos) + $P10 = rx925_cur."ws"() + unless $P10, rx925_fail + rx925_pos = $P10."pos"() + # rx rxquantr930 ** 0..1 + set_addr $I931, rxquantr930_done + rx925_cur."!mark_push"(0, rx925_pos, $I931) + rxquantr930_loop: # rx subrule "EXPR" subtype=capture negate= - rx896_cur."!cursor_pos"(rx896_pos) - $P10 = rx896_cur."EXPR"() - unless $P10, rx896_fail - rx896_cur."!mark_push"(0, -1, 0, $P10) + rx925_cur."!cursor_pos"(rx925_pos) + $P10 = rx925_cur."EXPR"() + unless $P10, rx925_fail + rx925_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("EXPR") - rx896_pos = $P10."pos"() - (rx896_rep) = rx896_cur."!mark_commit"($I902) - rxquantr901_done: + rx925_pos = $P10."pos"() + (rx925_rep) = rx925_cur."!mark_commit"($I931) + rxquantr930_done: # rx literal ")" - add $I11, rx896_pos, 1 - gt $I11, rx896_eos, rx896_fail - sub $I11, rx896_pos, rx896_off - substr $S10, rx896_tgt, $I11, 1 - ne $S10, ")", rx896_fail - add rx896_pos, 1 + add $I11, rx925_pos, 1 + gt $I11, rx925_eos, rx925_fail + sub $I11, rx925_pos, rx925_off + substr $S10, rx925_tgt, $I11, 1 + ne $S10, ")", rx925_fail + add rx925_pos, 1 # rx pass - rx896_cur."!cursor_pass"(rx896_pos, "circumfix:sym<( )>") - rx896_cur."!cursor_debug"("PASS ", "circumfix:sym<( )>", " at pos=", rx896_pos) - .return (rx896_cur) - rx896_fail: -.annotate 'line', 4 - (rx896_rep, rx896_pos, $I10, $P10) = rx896_cur."!mark_fail"(0) - lt rx896_pos, -1, rx896_done - eq rx896_pos, -1, rx896_fail + rx925_cur."!cursor_pass"(rx925_pos, "circumfix:sym<( )>") + rx925_cur."!cursor_debug"("PASS ", "circumfix:sym<( )>", " at pos=", rx925_pos) + .return (rx925_cur) + rx925_fail: +.annotate 'line', 4 + (rx925_rep, rx925_pos, $I10, $P10) = rx925_cur."!mark_fail"(0) + lt rx925_pos, -1, rx925_done + eq rx925_pos, -1, rx925_fail jump $I10 - rx896_done: - rx896_cur."!cursor_fail"() - rx896_cur."!cursor_debug"("FAIL ", "circumfix:sym<( )>") - .return (rx896_cur) + rx925_done: + rx925_cur."!cursor_fail"() + rx925_cur."!cursor_debug"("FAIL ", "circumfix:sym<( )>") + .return (rx925_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__circumfix:sym<( )>" :subid("216_1275511697.61926") :method +.sub "!PREFIX__circumfix:sym<( )>" :subid("225_1275600007.84296") :method .annotate 'line', 4 - $P898 = self."!PREFIX__!subrule"("", "(") - new $P899, "ResizablePMCArray" - push $P899, $P898 - .return ($P899) + $P927 = self."!PREFIX__!subrule"("", "(") + new $P928, "ResizablePMCArray" + push $P928, $P927 + .return ($P928) .end .namespace ["NQP";"Grammar"] -.sub "circumfix:sym<[ ]>" :subid("217_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "circumfix:sym<[ ]>" :subid("226_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx904_tgt - .local int rx904_pos - .local int rx904_off - .local int rx904_eos - .local int rx904_rep - .local pmc rx904_cur - (rx904_cur, rx904_pos, rx904_tgt) = self."!cursor_start"() - rx904_cur."!cursor_debug"("START ", "circumfix:sym<[ ]>") - rx904_cur."!cursor_caparray"("EXPR") - .lex unicode:"$\x{a2}", rx904_cur + .local string rx933_tgt + .local int rx933_pos + .local int rx933_off + .local int rx933_eos + .local int rx933_rep + .local pmc rx933_cur + (rx933_cur, rx933_pos, rx933_tgt) = self."!cursor_start"() + rx933_cur."!cursor_debug"("START ", "circumfix:sym<[ ]>") + rx933_cur."!cursor_caparray"("EXPR") + .lex unicode:"$\x{a2}", rx933_cur .local pmc match .lex "$/", match - length rx904_eos, rx904_tgt - gt rx904_pos, rx904_eos, rx904_done - set rx904_off, 0 - lt rx904_pos, 2, rx904_start - sub rx904_off, rx904_pos, 1 - substr rx904_tgt, rx904_tgt, rx904_off - rx904_start: + length rx933_eos, rx933_tgt + gt rx933_pos, rx933_eos, rx933_done + set rx933_off, 0 + lt rx933_pos, 2, rx933_start + sub rx933_off, rx933_pos, 1 + substr rx933_tgt, rx933_tgt, rx933_off + rx933_start: $I10 = self.'from'() - ne $I10, -1, rxscan908_done - goto rxscan908_scan - rxscan908_loop: - ($P10) = rx904_cur."from"() + ne $I10, -1, rxscan937_done + goto rxscan937_scan + rxscan937_loop: + ($P10) = rx933_cur."from"() inc $P10 - set rx904_pos, $P10 - ge rx904_pos, rx904_eos, rxscan908_done - rxscan908_scan: - set_addr $I10, rxscan908_loop - rx904_cur."!mark_push"(0, rx904_pos, $I10) - rxscan908_done: -.annotate 'line', 423 + set rx933_pos, $P10 + ge rx933_pos, rx933_eos, rxscan937_done + rxscan937_scan: + set_addr $I10, rxscan937_loop + rx933_cur."!mark_push"(0, rx933_pos, $I10) + rxscan937_done: +.annotate 'line', 435 # rx literal "[" - add $I11, rx904_pos, 1 - gt $I11, rx904_eos, rx904_fail - sub $I11, rx904_pos, rx904_off - substr $S10, rx904_tgt, $I11, 1 - ne $S10, "[", rx904_fail - add rx904_pos, 1 + add $I11, rx933_pos, 1 + gt $I11, rx933_eos, rx933_fail + sub $I11, rx933_pos, rx933_off + substr $S10, rx933_tgt, $I11, 1 + ne $S10, "[", rx933_fail + add rx933_pos, 1 # rx subrule "ws" subtype=method negate= - rx904_cur."!cursor_pos"(rx904_pos) - $P10 = rx904_cur."ws"() - unless $P10, rx904_fail - rx904_pos = $P10."pos"() - # rx rxquantr909 ** 0..1 - set_addr $I910, rxquantr909_done - rx904_cur."!mark_push"(0, rx904_pos, $I910) - rxquantr909_loop: + rx933_cur."!cursor_pos"(rx933_pos) + $P10 = rx933_cur."ws"() + unless $P10, rx933_fail + rx933_pos = $P10."pos"() + # rx rxquantr938 ** 0..1 + set_addr $I939, rxquantr938_done + rx933_cur."!mark_push"(0, rx933_pos, $I939) + rxquantr938_loop: # rx subrule "EXPR" subtype=capture negate= - rx904_cur."!cursor_pos"(rx904_pos) - $P10 = rx904_cur."EXPR"() - unless $P10, rx904_fail - rx904_cur."!mark_push"(0, -1, 0, $P10) + rx933_cur."!cursor_pos"(rx933_pos) + $P10 = rx933_cur."EXPR"() + unless $P10, rx933_fail + rx933_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("EXPR") - rx904_pos = $P10."pos"() - (rx904_rep) = rx904_cur."!mark_commit"($I910) - rxquantr909_done: + rx933_pos = $P10."pos"() + (rx933_rep) = rx933_cur."!mark_commit"($I939) + rxquantr938_done: # rx literal "]" - add $I11, rx904_pos, 1 - gt $I11, rx904_eos, rx904_fail - sub $I11, rx904_pos, rx904_off - substr $S10, rx904_tgt, $I11, 1 - ne $S10, "]", rx904_fail - add rx904_pos, 1 + add $I11, rx933_pos, 1 + gt $I11, rx933_eos, rx933_fail + sub $I11, rx933_pos, rx933_off + substr $S10, rx933_tgt, $I11, 1 + ne $S10, "]", rx933_fail + add rx933_pos, 1 # rx pass - rx904_cur."!cursor_pass"(rx904_pos, "circumfix:sym<[ ]>") - rx904_cur."!cursor_debug"("PASS ", "circumfix:sym<[ ]>", " at pos=", rx904_pos) - .return (rx904_cur) - rx904_fail: -.annotate 'line', 4 - (rx904_rep, rx904_pos, $I10, $P10) = rx904_cur."!mark_fail"(0) - lt rx904_pos, -1, rx904_done - eq rx904_pos, -1, rx904_fail + rx933_cur."!cursor_pass"(rx933_pos, "circumfix:sym<[ ]>") + rx933_cur."!cursor_debug"("PASS ", "circumfix:sym<[ ]>", " at pos=", rx933_pos) + .return (rx933_cur) + rx933_fail: +.annotate 'line', 4 + (rx933_rep, rx933_pos, $I10, $P10) = rx933_cur."!mark_fail"(0) + lt rx933_pos, -1, rx933_done + eq rx933_pos, -1, rx933_fail jump $I10 - rx904_done: - rx904_cur."!cursor_fail"() - rx904_cur."!cursor_debug"("FAIL ", "circumfix:sym<[ ]>") - .return (rx904_cur) + rx933_done: + rx933_cur."!cursor_fail"() + rx933_cur."!cursor_debug"("FAIL ", "circumfix:sym<[ ]>") + .return (rx933_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__circumfix:sym<[ ]>" :subid("218_1275511697.61926") :method +.sub "!PREFIX__circumfix:sym<[ ]>" :subid("227_1275600007.84296") :method .annotate 'line', 4 - $P906 = self."!PREFIX__!subrule"("", "[") - new $P907, "ResizablePMCArray" - push $P907, $P906 - .return ($P907) + $P935 = self."!PREFIX__!subrule"("", "[") + new $P936, "ResizablePMCArray" + push $P936, $P935 + .return ($P936) .end .namespace ["NQP";"Grammar"] -.sub "circumfix:sym" :subid("219_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "circumfix:sym" :subid("228_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx912_tgt - .local int rx912_pos - .local int rx912_off - .local int rx912_eos - .local int rx912_rep - .local pmc rx912_cur - (rx912_cur, rx912_pos, rx912_tgt) = self."!cursor_start"() - rx912_cur."!cursor_debug"("START ", "circumfix:sym") - .lex unicode:"$\x{a2}", rx912_cur + .local string rx941_tgt + .local int rx941_pos + .local int rx941_off + .local int rx941_eos + .local int rx941_rep + .local pmc rx941_cur + (rx941_cur, rx941_pos, rx941_tgt) = self."!cursor_start"() + rx941_cur."!cursor_debug"("START ", "circumfix:sym") + .lex unicode:"$\x{a2}", rx941_cur .local pmc match .lex "$/", match - length rx912_eos, rx912_tgt - gt rx912_pos, rx912_eos, rx912_done - set rx912_off, 0 - lt rx912_pos, 2, rx912_start - sub rx912_off, rx912_pos, 1 - substr rx912_tgt, rx912_tgt, rx912_off - rx912_start: + length rx941_eos, rx941_tgt + gt rx941_pos, rx941_eos, rx941_done + set rx941_off, 0 + lt rx941_pos, 2, rx941_start + sub rx941_off, rx941_pos, 1 + substr rx941_tgt, rx941_tgt, rx941_off + rx941_start: $I10 = self.'from'() - ne $I10, -1, rxscan915_done - goto rxscan915_scan - rxscan915_loop: - ($P10) = rx912_cur."from"() + ne $I10, -1, rxscan944_done + goto rxscan944_scan + rxscan944_loop: + ($P10) = rx941_cur."from"() inc $P10 - set rx912_pos, $P10 - ge rx912_pos, rx912_eos, rxscan915_done - rxscan915_scan: - set_addr $I10, rxscan915_loop - rx912_cur."!mark_push"(0, rx912_pos, $I10) - rxscan915_done: -.annotate 'line', 424 + set rx941_pos, $P10 + ge rx941_pos, rx941_eos, rxscan944_done + rxscan944_scan: + set_addr $I10, rxscan944_loop + rx941_cur."!mark_push"(0, rx941_pos, $I10) + rxscan944_done: +.annotate 'line', 436 # rx enumcharlist negate=0 zerowidth - ge rx912_pos, rx912_eos, rx912_fail - sub $I10, rx912_pos, rx912_off - substr $S10, rx912_tgt, $I10, 1 + ge rx941_pos, rx941_eos, rx941_fail + sub $I10, rx941_pos, rx941_off + substr $S10, rx941_tgt, $I10, 1 index $I11, "<", $S10 - lt $I11, 0, rx912_fail + lt $I11, 0, rx941_fail # rx subrule "quote_EXPR" subtype=capture negate= - rx912_cur."!cursor_pos"(rx912_pos) - $P10 = rx912_cur."quote_EXPR"(":q", ":w") - unless $P10, rx912_fail - rx912_cur."!mark_push"(0, -1, 0, $P10) + rx941_cur."!cursor_pos"(rx941_pos) + $P10 = rx941_cur."quote_EXPR"(":q", ":w") + unless $P10, rx941_fail + rx941_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quote_EXPR") - rx912_pos = $P10."pos"() + rx941_pos = $P10."pos"() # rx pass - rx912_cur."!cursor_pass"(rx912_pos, "circumfix:sym") - rx912_cur."!cursor_debug"("PASS ", "circumfix:sym", " at pos=", rx912_pos) - .return (rx912_cur) - rx912_fail: -.annotate 'line', 4 - (rx912_rep, rx912_pos, $I10, $P10) = rx912_cur."!mark_fail"(0) - lt rx912_pos, -1, rx912_done - eq rx912_pos, -1, rx912_fail + rx941_cur."!cursor_pass"(rx941_pos, "circumfix:sym") + rx941_cur."!cursor_debug"("PASS ", "circumfix:sym", " at pos=", rx941_pos) + .return (rx941_cur) + rx941_fail: +.annotate 'line', 4 + (rx941_rep, rx941_pos, $I10, $P10) = rx941_cur."!mark_fail"(0) + lt rx941_pos, -1, rx941_done + eq rx941_pos, -1, rx941_fail jump $I10 - rx912_done: - rx912_cur."!cursor_fail"() - rx912_cur."!cursor_debug"("FAIL ", "circumfix:sym") - .return (rx912_cur) + rx941_done: + rx941_cur."!cursor_fail"() + rx941_cur."!cursor_debug"("FAIL ", "circumfix:sym") + .return (rx941_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__circumfix:sym" :subid("220_1275511697.61926") :method +.sub "!PREFIX__circumfix:sym" :subid("229_1275600007.84296") :method .annotate 'line', 4 - new $P914, "ResizablePMCArray" - push $P914, "<" - .return ($P914) + new $P943, "ResizablePMCArray" + push $P943, "<" + .return ($P943) .end .namespace ["NQP";"Grammar"] -.sub unicode:"circumfix:sym<\x{ab} \x{bb}>" :subid("221_1275511697.61926") :method :outer("11_1275511697.61926") +.sub unicode:"circumfix:sym<\x{ab} \x{bb}>" :subid("230_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx917_tgt - .local int rx917_pos - .local int rx917_off - .local int rx917_eos - .local int rx917_rep - .local pmc rx917_cur - (rx917_cur, rx917_pos, rx917_tgt) = self."!cursor_start"() - rx917_cur."!cursor_debug"("START ", unicode:"circumfix:sym<\x{ab} \x{bb}>") - .lex unicode:"$\x{a2}", rx917_cur + .local string rx946_tgt + .local int rx946_pos + .local int rx946_off + .local int rx946_eos + .local int rx946_rep + .local pmc rx946_cur + (rx946_cur, rx946_pos, rx946_tgt) = self."!cursor_start"() + rx946_cur."!cursor_debug"("START ", unicode:"circumfix:sym<\x{ab} \x{bb}>") + .lex unicode:"$\x{a2}", rx946_cur .local pmc match .lex "$/", match - length rx917_eos, rx917_tgt - gt rx917_pos, rx917_eos, rx917_done - set rx917_off, 0 - lt rx917_pos, 2, rx917_start - sub rx917_off, rx917_pos, 1 - substr rx917_tgt, rx917_tgt, rx917_off - rx917_start: + length rx946_eos, rx946_tgt + gt rx946_pos, rx946_eos, rx946_done + set rx946_off, 0 + lt rx946_pos, 2, rx946_start + sub rx946_off, rx946_pos, 1 + substr rx946_tgt, rx946_tgt, rx946_off + rx946_start: $I10 = self.'from'() - ne $I10, -1, rxscan920_done - goto rxscan920_scan - rxscan920_loop: - ($P10) = rx917_cur."from"() + ne $I10, -1, rxscan949_done + goto rxscan949_scan + rxscan949_loop: + ($P10) = rx946_cur."from"() inc $P10 - set rx917_pos, $P10 - ge rx917_pos, rx917_eos, rxscan920_done - rxscan920_scan: - set_addr $I10, rxscan920_loop - rx917_cur."!mark_push"(0, rx917_pos, $I10) - rxscan920_done: -.annotate 'line', 425 + set rx946_pos, $P10 + ge rx946_pos, rx946_eos, rxscan949_done + rxscan949_scan: + set_addr $I10, rxscan949_loop + rx946_cur."!mark_push"(0, rx946_pos, $I10) + rxscan949_done: +.annotate 'line', 437 # rx enumcharlist negate=0 zerowidth - ge rx917_pos, rx917_eos, rx917_fail - sub $I10, rx917_pos, rx917_off - substr $S10, rx917_tgt, $I10, 1 + ge rx946_pos, rx946_eos, rx946_fail + sub $I10, rx946_pos, rx946_off + substr $S10, rx946_tgt, $I10, 1 index $I11, unicode:"\x{ab}", $S10 - lt $I11, 0, rx917_fail + lt $I11, 0, rx946_fail # rx subrule "quote_EXPR" subtype=capture negate= - rx917_cur."!cursor_pos"(rx917_pos) - $P10 = rx917_cur."quote_EXPR"(":qq", ":w") - unless $P10, rx917_fail - rx917_cur."!mark_push"(0, -1, 0, $P10) + rx946_cur."!cursor_pos"(rx946_pos) + $P10 = rx946_cur."quote_EXPR"(":qq", ":w") + unless $P10, rx946_fail + rx946_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quote_EXPR") - rx917_pos = $P10."pos"() + rx946_pos = $P10."pos"() # rx pass - rx917_cur."!cursor_pass"(rx917_pos, unicode:"circumfix:sym<\x{ab} \x{bb}>") - rx917_cur."!cursor_debug"("PASS ", unicode:"circumfix:sym<\x{ab} \x{bb}>", " at pos=", rx917_pos) - .return (rx917_cur) - rx917_fail: -.annotate 'line', 4 - (rx917_rep, rx917_pos, $I10, $P10) = rx917_cur."!mark_fail"(0) - lt rx917_pos, -1, rx917_done - eq rx917_pos, -1, rx917_fail + rx946_cur."!cursor_pass"(rx946_pos, unicode:"circumfix:sym<\x{ab} \x{bb}>") + rx946_cur."!cursor_debug"("PASS ", unicode:"circumfix:sym<\x{ab} \x{bb}>", " at pos=", rx946_pos) + .return (rx946_cur) + rx946_fail: +.annotate 'line', 4 + (rx946_rep, rx946_pos, $I10, $P10) = rx946_cur."!mark_fail"(0) + lt rx946_pos, -1, rx946_done + eq rx946_pos, -1, rx946_fail jump $I10 - rx917_done: - rx917_cur."!cursor_fail"() - rx917_cur."!cursor_debug"("FAIL ", unicode:"circumfix:sym<\x{ab} \x{bb}>") - .return (rx917_cur) + rx946_done: + rx946_cur."!cursor_fail"() + rx946_cur."!cursor_debug"("FAIL ", unicode:"circumfix:sym<\x{ab} \x{bb}>") + .return (rx946_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub unicode:"!PREFIX__circumfix:sym<\x{ab} \x{bb}>" :subid("222_1275511697.61926") :method +.sub unicode:"!PREFIX__circumfix:sym<\x{ab} \x{bb}>" :subid("231_1275600007.84296") :method .annotate 'line', 4 - new $P919, "ResizablePMCArray" - push $P919, unicode:"\x{ab}" - .return ($P919) + new $P948, "ResizablePMCArray" + push $P948, unicode:"\x{ab}" + .return ($P948) .end .namespace ["NQP";"Grammar"] -.sub "circumfix:sym<{ }>" :subid("223_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "circumfix:sym<{ }>" :subid("232_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx922_tgt - .local int rx922_pos - .local int rx922_off - .local int rx922_eos - .local int rx922_rep - .local pmc rx922_cur - (rx922_cur, rx922_pos, rx922_tgt) = self."!cursor_start"() - rx922_cur."!cursor_debug"("START ", "circumfix:sym<{ }>") - .lex unicode:"$\x{a2}", rx922_cur + .local string rx951_tgt + .local int rx951_pos + .local int rx951_off + .local int rx951_eos + .local int rx951_rep + .local pmc rx951_cur + (rx951_cur, rx951_pos, rx951_tgt) = self."!cursor_start"() + rx951_cur."!cursor_debug"("START ", "circumfix:sym<{ }>") + .lex unicode:"$\x{a2}", rx951_cur .local pmc match .lex "$/", match - length rx922_eos, rx922_tgt - gt rx922_pos, rx922_eos, rx922_done - set rx922_off, 0 - lt rx922_pos, 2, rx922_start - sub rx922_off, rx922_pos, 1 - substr rx922_tgt, rx922_tgt, rx922_off - rx922_start: + length rx951_eos, rx951_tgt + gt rx951_pos, rx951_eos, rx951_done + set rx951_off, 0 + lt rx951_pos, 2, rx951_start + sub rx951_off, rx951_pos, 1 + substr rx951_tgt, rx951_tgt, rx951_off + rx951_start: $I10 = self.'from'() - ne $I10, -1, rxscan925_done - goto rxscan925_scan - rxscan925_loop: - ($P10) = rx922_cur."from"() + ne $I10, -1, rxscan954_done + goto rxscan954_scan + rxscan954_loop: + ($P10) = rx951_cur."from"() inc $P10 - set rx922_pos, $P10 - ge rx922_pos, rx922_eos, rxscan925_done - rxscan925_scan: - set_addr $I10, rxscan925_loop - rx922_cur."!mark_push"(0, rx922_pos, $I10) - rxscan925_done: -.annotate 'line', 426 + set rx951_pos, $P10 + ge rx951_pos, rx951_eos, rxscan954_done + rxscan954_scan: + set_addr $I10, rxscan954_loop + rx951_cur."!mark_push"(0, rx951_pos, $I10) + rxscan954_done: +.annotate 'line', 438 # rx enumcharlist negate=0 zerowidth - ge rx922_pos, rx922_eos, rx922_fail - sub $I10, rx922_pos, rx922_off - substr $S10, rx922_tgt, $I10, 1 + ge rx951_pos, rx951_eos, rx951_fail + sub $I10, rx951_pos, rx951_off + substr $S10, rx951_tgt, $I10, 1 index $I11, "{", $S10 - lt $I11, 0, rx922_fail + lt $I11, 0, rx951_fail # rx subrule "pblock" subtype=capture negate= - rx922_cur."!cursor_pos"(rx922_pos) - $P10 = rx922_cur."pblock"() - unless $P10, rx922_fail - rx922_cur."!mark_push"(0, -1, 0, $P10) + rx951_cur."!cursor_pos"(rx951_pos) + $P10 = rx951_cur."pblock"() + unless $P10, rx951_fail + rx951_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("pblock") - rx922_pos = $P10."pos"() + rx951_pos = $P10."pos"() # rx pass - rx922_cur."!cursor_pass"(rx922_pos, "circumfix:sym<{ }>") - rx922_cur."!cursor_debug"("PASS ", "circumfix:sym<{ }>", " at pos=", rx922_pos) - .return (rx922_cur) - rx922_fail: -.annotate 'line', 4 - (rx922_rep, rx922_pos, $I10, $P10) = rx922_cur."!mark_fail"(0) - lt rx922_pos, -1, rx922_done - eq rx922_pos, -1, rx922_fail + rx951_cur."!cursor_pass"(rx951_pos, "circumfix:sym<{ }>") + rx951_cur."!cursor_debug"("PASS ", "circumfix:sym<{ }>", " at pos=", rx951_pos) + .return (rx951_cur) + rx951_fail: +.annotate 'line', 4 + (rx951_rep, rx951_pos, $I10, $P10) = rx951_cur."!mark_fail"(0) + lt rx951_pos, -1, rx951_done + eq rx951_pos, -1, rx951_fail jump $I10 - rx922_done: - rx922_cur."!cursor_fail"() - rx922_cur."!cursor_debug"("FAIL ", "circumfix:sym<{ }>") - .return (rx922_cur) + rx951_done: + rx951_cur."!cursor_fail"() + rx951_cur."!cursor_debug"("FAIL ", "circumfix:sym<{ }>") + .return (rx951_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__circumfix:sym<{ }>" :subid("224_1275511697.61926") :method +.sub "!PREFIX__circumfix:sym<{ }>" :subid("233_1275600007.84296") :method .annotate 'line', 4 - new $P924, "ResizablePMCArray" - push $P924, "{" - .return ($P924) + new $P953, "ResizablePMCArray" + push $P953, "{" + .return ($P953) .end .namespace ["NQP";"Grammar"] -.sub "circumfix:sym" :subid("225_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "circumfix:sym" :subid("234_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx927_tgt - .local int rx927_pos - .local int rx927_off - .local int rx927_eos - .local int rx927_rep - .local pmc rx927_cur - (rx927_cur, rx927_pos, rx927_tgt) = self."!cursor_start"() - rx927_cur."!cursor_debug"("START ", "circumfix:sym") - .lex unicode:"$\x{a2}", rx927_cur + .local string rx956_tgt + .local int rx956_pos + .local int rx956_off + .local int rx956_eos + .local int rx956_rep + .local pmc rx956_cur + (rx956_cur, rx956_pos, rx956_tgt) = self."!cursor_start"() + rx956_cur."!cursor_debug"("START ", "circumfix:sym") + .lex unicode:"$\x{a2}", rx956_cur .local pmc match .lex "$/", match - length rx927_eos, rx927_tgt - gt rx927_pos, rx927_eos, rx927_done - set rx927_off, 0 - lt rx927_pos, 2, rx927_start - sub rx927_off, rx927_pos, 1 - substr rx927_tgt, rx927_tgt, rx927_off - rx927_start: + length rx956_eos, rx956_tgt + gt rx956_pos, rx956_eos, rx956_done + set rx956_off, 0 + lt rx956_pos, 2, rx956_start + sub rx956_off, rx956_pos, 1 + substr rx956_tgt, rx956_tgt, rx956_off + rx956_start: $I10 = self.'from'() - ne $I10, -1, rxscan931_done - goto rxscan931_scan - rxscan931_loop: - ($P10) = rx927_cur."from"() + ne $I10, -1, rxscan960_done + goto rxscan960_scan + rxscan960_loop: + ($P10) = rx956_cur."from"() inc $P10 - set rx927_pos, $P10 - ge rx927_pos, rx927_eos, rxscan931_done - rxscan931_scan: - set_addr $I10, rxscan931_loop - rx927_cur."!mark_push"(0, rx927_pos, $I10) - rxscan931_done: -.annotate 'line', 427 + set rx956_pos, $P10 + ge rx956_pos, rx956_eos, rxscan960_done + rxscan960_scan: + set_addr $I10, rxscan960_loop + rx956_cur."!mark_push"(0, rx956_pos, $I10) + rxscan960_done: +.annotate 'line', 439 # rx subrule "sigil" subtype=capture negate= - rx927_cur."!cursor_pos"(rx927_pos) - $P10 = rx927_cur."sigil"() - unless $P10, rx927_fail - rx927_cur."!mark_push"(0, -1, 0, $P10) + rx956_cur."!cursor_pos"(rx956_pos) + $P10 = rx956_cur."sigil"() + unless $P10, rx956_fail + rx956_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sigil") - rx927_pos = $P10."pos"() + rx956_pos = $P10."pos"() # rx literal "(" - add $I11, rx927_pos, 1 - gt $I11, rx927_eos, rx927_fail - sub $I11, rx927_pos, rx927_off - substr $S10, rx927_tgt, $I11, 1 - ne $S10, "(", rx927_fail - add rx927_pos, 1 + add $I11, rx956_pos, 1 + gt $I11, rx956_eos, rx956_fail + sub $I11, rx956_pos, rx956_off + substr $S10, rx956_tgt, $I11, 1 + ne $S10, "(", rx956_fail + add rx956_pos, 1 # rx subrule "semilist" subtype=capture negate= - rx927_cur."!cursor_pos"(rx927_pos) - $P10 = rx927_cur."semilist"() - unless $P10, rx927_fail - rx927_cur."!mark_push"(0, -1, 0, $P10) + rx956_cur."!cursor_pos"(rx956_pos) + $P10 = rx956_cur."semilist"() + unless $P10, rx956_fail + rx956_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("semilist") - rx927_pos = $P10."pos"() - alt932_0: - set_addr $I10, alt932_1 - rx927_cur."!mark_push"(0, rx927_pos, $I10) + rx956_pos = $P10."pos"() + alt961_0: + set_addr $I10, alt961_1 + rx956_cur."!mark_push"(0, rx956_pos, $I10) # rx literal ")" - add $I11, rx927_pos, 1 - gt $I11, rx927_eos, rx927_fail - sub $I11, rx927_pos, rx927_off - substr $S10, rx927_tgt, $I11, 1 - ne $S10, ")", rx927_fail - add rx927_pos, 1 - goto alt932_end - alt932_1: + add $I11, rx956_pos, 1 + gt $I11, rx956_eos, rx956_fail + sub $I11, rx956_pos, rx956_off + substr $S10, rx956_tgt, $I11, 1 + ne $S10, ")", rx956_fail + add rx956_pos, 1 + goto alt961_end + alt961_1: # rx subrule "FAILGOAL" subtype=method negate= - rx927_cur."!cursor_pos"(rx927_pos) - $P10 = rx927_cur."FAILGOAL"("')'") - unless $P10, rx927_fail - rx927_pos = $P10."pos"() - alt932_end: + rx956_cur."!cursor_pos"(rx956_pos) + $P10 = rx956_cur."FAILGOAL"("')'") + unless $P10, rx956_fail + rx956_pos = $P10."pos"() + alt961_end: # rx pass - rx927_cur."!cursor_pass"(rx927_pos, "circumfix:sym") - rx927_cur."!cursor_debug"("PASS ", "circumfix:sym", " at pos=", rx927_pos) - .return (rx927_cur) - rx927_fail: -.annotate 'line', 4 - (rx927_rep, rx927_pos, $I10, $P10) = rx927_cur."!mark_fail"(0) - lt rx927_pos, -1, rx927_done - eq rx927_pos, -1, rx927_fail + rx956_cur."!cursor_pass"(rx956_pos, "circumfix:sym") + rx956_cur."!cursor_debug"("PASS ", "circumfix:sym", " at pos=", rx956_pos) + .return (rx956_cur) + rx956_fail: +.annotate 'line', 4 + (rx956_rep, rx956_pos, $I10, $P10) = rx956_cur."!mark_fail"(0) + lt rx956_pos, -1, rx956_done + eq rx956_pos, -1, rx956_fail jump $I10 - rx927_done: - rx927_cur."!cursor_fail"() - rx927_cur."!cursor_debug"("FAIL ", "circumfix:sym") - .return (rx927_cur) + rx956_done: + rx956_cur."!cursor_fail"() + rx956_cur."!cursor_debug"("FAIL ", "circumfix:sym") + .return (rx956_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__circumfix:sym" :subid("226_1275511697.61926") :method +.sub "!PREFIX__circumfix:sym" :subid("235_1275600007.84296") :method .annotate 'line', 4 - $P929 = self."!PREFIX__!subrule"("sigil", "") - new $P930, "ResizablePMCArray" - push $P930, $P929 - .return ($P930) + $P958 = self."!PREFIX__!subrule"("sigil", "") + new $P959, "ResizablePMCArray" + push $P959, $P958 + .return ($P959) .end .namespace ["NQP";"Grammar"] -.sub "semilist" :subid("227_1275511697.61926") :method :outer("11_1275511697.61926") +.sub "semilist" :subid("236_1275600007.84296") :method :outer("11_1275600007.84296") .annotate 'line', 4 - .local string rx935_tgt - .local int rx935_pos - .local int rx935_off - .local int rx935_eos - .local int rx935_rep - .local pmc rx935_cur - (rx935_cur, rx935_pos, rx935_tgt) = self."!cursor_start"() - rx935_cur."!cursor_debug"("START ", "semilist") - .lex unicode:"$\x{a2}", rx935_cur - .local pmc match - .lex "$/", match - length rx935_eos, rx935_tgt - gt rx935_pos, rx935_eos, rx935_done - set rx935_off, 0 - lt rx935_pos, 2, rx935_start - sub rx935_off, rx935_pos, 1 - substr rx935_tgt, rx935_tgt, rx935_off - rx935_start: - $I10 = self.'from'() - ne $I10, -1, rxscan938_done - goto rxscan938_scan - rxscan938_loop: - ($P10) = rx935_cur."from"() - inc $P10 - set rx935_pos, $P10 - ge rx935_pos, rx935_eos, rxscan938_done - rxscan938_scan: - set_addr $I10, rxscan938_loop - rx935_cur."!mark_push"(0, rx935_pos, $I10) - rxscan938_done: -.annotate 'line', 429 - # rx subrule "ws" subtype=method negate= - rx935_cur."!cursor_pos"(rx935_pos) - $P10 = rx935_cur."ws"() - unless $P10, rx935_fail - rx935_pos = $P10."pos"() - # rx subrule "statement" subtype=capture negate= - rx935_cur."!cursor_pos"(rx935_pos) - $P10 = rx935_cur."statement"() - unless $P10, rx935_fail - rx935_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("statement") - rx935_pos = $P10."pos"() - # rx subrule "ws" subtype=method negate= - rx935_cur."!cursor_pos"(rx935_pos) - $P10 = rx935_cur."ws"() - unless $P10, rx935_fail - rx935_pos = $P10."pos"() - # rx pass - rx935_cur."!cursor_pass"(rx935_pos, "semilist") - rx935_cur."!cursor_debug"("PASS ", "semilist", " at pos=", rx935_pos) - .return (rx935_cur) - rx935_fail: -.annotate 'line', 4 - (rx935_rep, rx935_pos, $I10, $P10) = rx935_cur."!mark_fail"(0) - lt rx935_pos, -1, rx935_done - eq rx935_pos, -1, rx935_fail - jump $I10 - rx935_done: - rx935_cur."!cursor_fail"() - rx935_cur."!cursor_debug"("FAIL ", "semilist") - .return (rx935_cur) - .return () -.end - - -.namespace ["NQP";"Grammar"] -.sub "!PREFIX__semilist" :subid("228_1275511697.61926") :method -.annotate 'line', 4 - new $P937, "ResizablePMCArray" - push $P937, "" - .return ($P937) -.end - - -.namespace ["NQP";"Grammar"] -.sub "infixish" :subid("229_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx942_tgt - .local int rx942_pos - .local int rx942_off - .local int rx942_eos - .local int rx942_rep - .local pmc rx942_cur - (rx942_cur, rx942_pos, rx942_tgt) = self."!cursor_start"() - rx942_cur."!cursor_debug"("START ", "infixish") - .lex unicode:"$\x{a2}", rx942_cur - .local pmc match - .lex "$/", match - length rx942_eos, rx942_tgt - gt rx942_pos, rx942_eos, rx942_done - set rx942_off, 0 - lt rx942_pos, 2, rx942_start - sub rx942_off, rx942_pos, 1 - substr rx942_tgt, rx942_tgt, rx942_off - rx942_start: - $I10 = self.'from'() - ne $I10, -1, rxscan945_done - goto rxscan945_scan - rxscan945_loop: - ($P10) = rx942_cur."from"() - inc $P10 - set rx942_pos, $P10 - ge rx942_pos, rx942_eos, rxscan945_done - rxscan945_scan: - set_addr $I10, rxscan945_loop - rx942_cur."!mark_push"(0, rx942_pos, $I10) - rxscan945_done: -.annotate 'line', 452 - # rx subrule "infixstopper" subtype=zerowidth negate=1 - rx942_cur."!cursor_pos"(rx942_pos) - $P10 = rx942_cur."infixstopper"() - if $P10, rx942_fail - # rx subrule "infix" subtype=capture negate= - rx942_cur."!cursor_pos"(rx942_pos) - $P10 = rx942_cur."infix"() - unless $P10, rx942_fail - rx942_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("OPER=infix") - rx942_pos = $P10."pos"() - # rx pass - rx942_cur."!cursor_pass"(rx942_pos, "infixish") - rx942_cur."!cursor_debug"("PASS ", "infixish", " at pos=", rx942_pos) - .return (rx942_cur) - rx942_fail: -.annotate 'line', 433 - (rx942_rep, rx942_pos, $I10, $P10) = rx942_cur."!mark_fail"(0) - lt rx942_pos, -1, rx942_done - eq rx942_pos, -1, rx942_fail - jump $I10 - rx942_done: - rx942_cur."!cursor_fail"() - rx942_cur."!cursor_debug"("FAIL ", "infixish") - .return (rx942_cur) - .return () -.end - - -.namespace ["NQP";"Grammar"] -.sub "!PREFIX__infixish" :subid("230_1275511697.61926") :method -.annotate 'line', 433 - new $P944, "ResizablePMCArray" - push $P944, "" - .return ($P944) -.end - - -.namespace ["NQP";"Grammar"] -.sub "infixstopper" :subid("231_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx947_tgt - .local int rx947_pos - .local int rx947_off - .local int rx947_eos - .local int rx947_rep - .local pmc rx947_cur - (rx947_cur, rx947_pos, rx947_tgt) = self."!cursor_start"() - rx947_cur."!cursor_debug"("START ", "infixstopper") - .lex unicode:"$\x{a2}", rx947_cur - .local pmc match - .lex "$/", match - length rx947_eos, rx947_tgt - gt rx947_pos, rx947_eos, rx947_done - set rx947_off, 0 - lt rx947_pos, 2, rx947_start - sub rx947_off, rx947_pos, 1 - substr rx947_tgt, rx947_tgt, rx947_off - rx947_start: - $I10 = self.'from'() - ne $I10, -1, rxscan950_done - goto rxscan950_scan - rxscan950_loop: - ($P10) = rx947_cur."from"() - inc $P10 - set rx947_pos, $P10 - ge rx947_pos, rx947_eos, rxscan950_done - rxscan950_scan: - set_addr $I10, rxscan950_loop - rx947_cur."!mark_push"(0, rx947_pos, $I10) - rxscan950_done: -.annotate 'line', 453 - # rx subrule "lambda" subtype=zerowidth negate= - rx947_cur."!cursor_pos"(rx947_pos) - $P10 = rx947_cur."lambda"() - unless $P10, rx947_fail - # rx pass - rx947_cur."!cursor_pass"(rx947_pos, "infixstopper") - rx947_cur."!cursor_debug"("PASS ", "infixstopper", " at pos=", rx947_pos) - .return (rx947_cur) - rx947_fail: -.annotate 'line', 433 - (rx947_rep, rx947_pos, $I10, $P10) = rx947_cur."!mark_fail"(0) - lt rx947_pos, -1, rx947_done - eq rx947_pos, -1, rx947_fail - jump $I10 - rx947_done: - rx947_cur."!cursor_fail"() - rx947_cur."!cursor_debug"("FAIL ", "infixstopper") - .return (rx947_cur) - .return () -.end - - -.namespace ["NQP";"Grammar"] -.sub "!PREFIX__infixstopper" :subid("232_1275511697.61926") :method -.annotate 'line', 433 - new $P949, "ResizablePMCArray" - push $P949, "" - .return ($P949) -.end - - -.namespace ["NQP";"Grammar"] -.sub "postcircumfix:sym<[ ]>" :subid("233_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx952_tgt - .local int rx952_pos - .local int rx952_off - .local int rx952_eos - .local int rx952_rep - .local pmc rx952_cur - (rx952_cur, rx952_pos, rx952_tgt) = self."!cursor_start"() - rx952_cur."!cursor_debug"("START ", "postcircumfix:sym<[ ]>") - .lex unicode:"$\x{a2}", rx952_cur - .local pmc match - .lex "$/", match - length rx952_eos, rx952_tgt - gt rx952_pos, rx952_eos, rx952_done - set rx952_off, 0 - lt rx952_pos, 2, rx952_start - sub rx952_off, rx952_pos, 1 - substr rx952_tgt, rx952_tgt, rx952_off - rx952_start: - $I10 = self.'from'() - ne $I10, -1, rxscan956_done - goto rxscan956_scan - rxscan956_loop: - ($P10) = rx952_cur."from"() - inc $P10 - set rx952_pos, $P10 - ge rx952_pos, rx952_eos, rxscan956_done - rxscan956_scan: - set_addr $I10, rxscan956_loop - rx952_cur."!mark_push"(0, rx952_pos, $I10) - rxscan956_done: -.annotate 'line', 456 - # rx literal "[" - add $I11, rx952_pos, 1 - gt $I11, rx952_eos, rx952_fail - sub $I11, rx952_pos, rx952_off - substr $S10, rx952_tgt, $I11, 1 - ne $S10, "[", rx952_fail - add rx952_pos, 1 - # rx subrule "ws" subtype=method negate= - rx952_cur."!cursor_pos"(rx952_pos) - $P10 = rx952_cur."ws"() - unless $P10, rx952_fail - rx952_pos = $P10."pos"() - # rx subrule "EXPR" subtype=capture negate= - rx952_cur."!cursor_pos"(rx952_pos) - $P10 = rx952_cur."EXPR"() - unless $P10, rx952_fail - rx952_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("EXPR") - rx952_pos = $P10."pos"() - # rx literal "]" - add $I11, rx952_pos, 1 - gt $I11, rx952_eos, rx952_fail - sub $I11, rx952_pos, rx952_off - substr $S10, rx952_tgt, $I11, 1 - ne $S10, "]", rx952_fail - add rx952_pos, 1 -.annotate 'line', 457 - # rx subrule "O" subtype=capture negate= - rx952_cur."!cursor_pos"(rx952_pos) - $P10 = rx952_cur."O"("%methodop") - unless $P10, rx952_fail - rx952_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("O") - rx952_pos = $P10."pos"() -.annotate 'line', 455 - # rx pass - rx952_cur."!cursor_pass"(rx952_pos, "postcircumfix:sym<[ ]>") - rx952_cur."!cursor_debug"("PASS ", "postcircumfix:sym<[ ]>", " at pos=", rx952_pos) - .return (rx952_cur) - rx952_fail: -.annotate 'line', 433 - (rx952_rep, rx952_pos, $I10, $P10) = rx952_cur."!mark_fail"(0) - lt rx952_pos, -1, rx952_done - eq rx952_pos, -1, rx952_fail - jump $I10 - rx952_done: - rx952_cur."!cursor_fail"() - rx952_cur."!cursor_debug"("FAIL ", "postcircumfix:sym<[ ]>") - .return (rx952_cur) - .return () -.end - - -.namespace ["NQP";"Grammar"] -.sub "!PREFIX__postcircumfix:sym<[ ]>" :subid("234_1275511697.61926") :method -.annotate 'line', 433 - $P954 = self."!PREFIX__!subrule"("", "[") - new $P955, "ResizablePMCArray" - push $P955, $P954 - .return ($P955) -.end - - -.namespace ["NQP";"Grammar"] -.sub "postcircumfix:sym<{ }>" :subid("235_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx958_tgt - .local int rx958_pos - .local int rx958_off - .local int rx958_eos - .local int rx958_rep - .local pmc rx958_cur - (rx958_cur, rx958_pos, rx958_tgt) = self."!cursor_start"() - rx958_cur."!cursor_debug"("START ", "postcircumfix:sym<{ }>") - .lex unicode:"$\x{a2}", rx958_cur - .local pmc match - .lex "$/", match - length rx958_eos, rx958_tgt - gt rx958_pos, rx958_eos, rx958_done - set rx958_off, 0 - lt rx958_pos, 2, rx958_start - sub rx958_off, rx958_pos, 1 - substr rx958_tgt, rx958_tgt, rx958_off - rx958_start: - $I10 = self.'from'() - ne $I10, -1, rxscan962_done - goto rxscan962_scan - rxscan962_loop: - ($P10) = rx958_cur."from"() - inc $P10 - set rx958_pos, $P10 - ge rx958_pos, rx958_eos, rxscan962_done - rxscan962_scan: - set_addr $I10, rxscan962_loop - rx958_cur."!mark_push"(0, rx958_pos, $I10) - rxscan962_done: -.annotate 'line', 461 - # rx literal "{" - add $I11, rx958_pos, 1 - gt $I11, rx958_eos, rx958_fail - sub $I11, rx958_pos, rx958_off - substr $S10, rx958_tgt, $I11, 1 - ne $S10, "{", rx958_fail - add rx958_pos, 1 - # rx subrule "ws" subtype=method negate= - rx958_cur."!cursor_pos"(rx958_pos) - $P10 = rx958_cur."ws"() - unless $P10, rx958_fail - rx958_pos = $P10."pos"() - # rx subrule "EXPR" subtype=capture negate= - rx958_cur."!cursor_pos"(rx958_pos) - $P10 = rx958_cur."EXPR"() - unless $P10, rx958_fail - rx958_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("EXPR") - rx958_pos = $P10."pos"() - # rx literal "}" - add $I11, rx958_pos, 1 - gt $I11, rx958_eos, rx958_fail - sub $I11, rx958_pos, rx958_off - substr $S10, rx958_tgt, $I11, 1 - ne $S10, "}", rx958_fail - add rx958_pos, 1 -.annotate 'line', 462 - # rx subrule "O" subtype=capture negate= - rx958_cur."!cursor_pos"(rx958_pos) - $P10 = rx958_cur."O"("%methodop") - unless $P10, rx958_fail - rx958_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("O") - rx958_pos = $P10."pos"() -.annotate 'line', 460 - # rx pass - rx958_cur."!cursor_pass"(rx958_pos, "postcircumfix:sym<{ }>") - rx958_cur."!cursor_debug"("PASS ", "postcircumfix:sym<{ }>", " at pos=", rx958_pos) - .return (rx958_cur) - rx958_fail: -.annotate 'line', 433 - (rx958_rep, rx958_pos, $I10, $P10) = rx958_cur."!mark_fail"(0) - lt rx958_pos, -1, rx958_done - eq rx958_pos, -1, rx958_fail - jump $I10 - rx958_done: - rx958_cur."!cursor_fail"() - rx958_cur."!cursor_debug"("FAIL ", "postcircumfix:sym<{ }>") - .return (rx958_cur) - .return () -.end - - -.namespace ["NQP";"Grammar"] -.sub "!PREFIX__postcircumfix:sym<{ }>" :subid("236_1275511697.61926") :method -.annotate 'line', 433 - $P960 = self."!PREFIX__!subrule"("", "{") - new $P961, "ResizablePMCArray" - push $P961, $P960 - .return ($P961) -.end - - -.namespace ["NQP";"Grammar"] -.sub "postcircumfix:sym" :subid("237_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 .local string rx964_tgt .local int rx964_pos .local int rx964_off @@ -11750,7 +11709,7 @@ NQP::Compiler - NQP compiler .local int rx964_rep .local pmc rx964_cur (rx964_cur, rx964_pos, rx964_tgt) = self."!cursor_start"() - rx964_cur."!cursor_debug"("START ", "postcircumfix:sym") + rx964_cur."!cursor_debug"("START ", "semilist") .lex unicode:"$\x{a2}", rx964_cur .local pmc match .lex "$/", match @@ -11773,232 +11732,191 @@ NQP::Compiler - NQP compiler set_addr $I10, rxscan967_loop rx964_cur."!mark_push"(0, rx964_pos, $I10) rxscan967_done: -.annotate 'line', 466 - # rx enumcharlist negate=0 zerowidth - ge rx964_pos, rx964_eos, rx964_fail - sub $I10, rx964_pos, rx964_off - substr $S10, rx964_tgt, $I10, 1 - index $I11, "<", $S10 - lt $I11, 0, rx964_fail - # rx subrule "quote_EXPR" subtype=capture negate= +.annotate 'line', 441 + # rx subrule "ws" subtype=method negate= rx964_cur."!cursor_pos"(rx964_pos) - $P10 = rx964_cur."quote_EXPR"(":q") + $P10 = rx964_cur."ws"() unless $P10, rx964_fail - rx964_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("quote_EXPR") rx964_pos = $P10."pos"() -.annotate 'line', 467 - # rx subrule "O" subtype=capture negate= + # rx subrule "statement" subtype=capture negate= rx964_cur."!cursor_pos"(rx964_pos) - $P10 = rx964_cur."O"("%methodop") + $P10 = rx964_cur."statement"() unless $P10, rx964_fail rx964_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("O") + $P10."!cursor_names"("statement") + rx964_pos = $P10."pos"() + # rx subrule "ws" subtype=method negate= + rx964_cur."!cursor_pos"(rx964_pos) + $P10 = rx964_cur."ws"() + unless $P10, rx964_fail rx964_pos = $P10."pos"() -.annotate 'line', 465 # rx pass - rx964_cur."!cursor_pass"(rx964_pos, "postcircumfix:sym") - rx964_cur."!cursor_debug"("PASS ", "postcircumfix:sym", " at pos=", rx964_pos) + rx964_cur."!cursor_pass"(rx964_pos, "semilist") + rx964_cur."!cursor_debug"("PASS ", "semilist", " at pos=", rx964_pos) .return (rx964_cur) rx964_fail: -.annotate 'line', 433 +.annotate 'line', 4 (rx964_rep, rx964_pos, $I10, $P10) = rx964_cur."!mark_fail"(0) lt rx964_pos, -1, rx964_done eq rx964_pos, -1, rx964_fail jump $I10 rx964_done: rx964_cur."!cursor_fail"() - rx964_cur."!cursor_debug"("FAIL ", "postcircumfix:sym") + rx964_cur."!cursor_debug"("FAIL ", "semilist") .return (rx964_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__postcircumfix:sym" :subid("238_1275511697.61926") :method -.annotate 'line', 433 +.sub "!PREFIX__semilist" :subid("237_1275600007.84296") :method +.annotate 'line', 4 new $P966, "ResizablePMCArray" - push $P966, "<" + push $P966, "" .return ($P966) .end .namespace ["NQP";"Grammar"] -.sub "postcircumfix:sym<( )>" :subid("239_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx969_tgt - .local int rx969_pos - .local int rx969_off - .local int rx969_eos - .local int rx969_rep - .local pmc rx969_cur - (rx969_cur, rx969_pos, rx969_tgt) = self."!cursor_start"() - rx969_cur."!cursor_debug"("START ", "postcircumfix:sym<( )>") - .lex unicode:"$\x{a2}", rx969_cur +.sub "infixish" :subid("238_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx971_tgt + .local int rx971_pos + .local int rx971_off + .local int rx971_eos + .local int rx971_rep + .local pmc rx971_cur + (rx971_cur, rx971_pos, rx971_tgt) = self."!cursor_start"() + rx971_cur."!cursor_debug"("START ", "infixish") + .lex unicode:"$\x{a2}", rx971_cur .local pmc match .lex "$/", match - length rx969_eos, rx969_tgt - gt rx969_pos, rx969_eos, rx969_done - set rx969_off, 0 - lt rx969_pos, 2, rx969_start - sub rx969_off, rx969_pos, 1 - substr rx969_tgt, rx969_tgt, rx969_off - rx969_start: + length rx971_eos, rx971_tgt + gt rx971_pos, rx971_eos, rx971_done + set rx971_off, 0 + lt rx971_pos, 2, rx971_start + sub rx971_off, rx971_pos, 1 + substr rx971_tgt, rx971_tgt, rx971_off + rx971_start: $I10 = self.'from'() - ne $I10, -1, rxscan973_done - goto rxscan973_scan - rxscan973_loop: - ($P10) = rx969_cur."from"() + ne $I10, -1, rxscan974_done + goto rxscan974_scan + rxscan974_loop: + ($P10) = rx971_cur."from"() inc $P10 - set rx969_pos, $P10 - ge rx969_pos, rx969_eos, rxscan973_done - rxscan973_scan: - set_addr $I10, rxscan973_loop - rx969_cur."!mark_push"(0, rx969_pos, $I10) - rxscan973_done: -.annotate 'line', 471 - # rx literal "(" - add $I11, rx969_pos, 1 - gt $I11, rx969_eos, rx969_fail - sub $I11, rx969_pos, rx969_off - substr $S10, rx969_tgt, $I11, 1 - ne $S10, "(", rx969_fail - add rx969_pos, 1 - # rx subrule "ws" subtype=method negate= - rx969_cur."!cursor_pos"(rx969_pos) - $P10 = rx969_cur."ws"() - unless $P10, rx969_fail - rx969_pos = $P10."pos"() - # rx subrule "arglist" subtype=capture negate= - rx969_cur."!cursor_pos"(rx969_pos) - $P10 = rx969_cur."arglist"() - unless $P10, rx969_fail - rx969_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("arglist") - rx969_pos = $P10."pos"() - # rx literal ")" - add $I11, rx969_pos, 1 - gt $I11, rx969_eos, rx969_fail - sub $I11, rx969_pos, rx969_off - substr $S10, rx969_tgt, $I11, 1 - ne $S10, ")", rx969_fail - add rx969_pos, 1 -.annotate 'line', 472 - # rx subrule "O" subtype=capture negate= - rx969_cur."!cursor_pos"(rx969_pos) - $P10 = rx969_cur."O"("%methodop") - unless $P10, rx969_fail - rx969_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("O") - rx969_pos = $P10."pos"() -.annotate 'line', 470 + set rx971_pos, $P10 + ge rx971_pos, rx971_eos, rxscan974_done + rxscan974_scan: + set_addr $I10, rxscan974_loop + rx971_cur."!mark_push"(0, rx971_pos, $I10) + rxscan974_done: +.annotate 'line', 464 + # rx subrule "infixstopper" subtype=zerowidth negate=1 + rx971_cur."!cursor_pos"(rx971_pos) + $P10 = rx971_cur."infixstopper"() + if $P10, rx971_fail + # rx subrule "infix" subtype=capture negate= + rx971_cur."!cursor_pos"(rx971_pos) + $P10 = rx971_cur."infix"() + unless $P10, rx971_fail + rx971_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("OPER=infix") + rx971_pos = $P10."pos"() # rx pass - rx969_cur."!cursor_pass"(rx969_pos, "postcircumfix:sym<( )>") - rx969_cur."!cursor_debug"("PASS ", "postcircumfix:sym<( )>", " at pos=", rx969_pos) - .return (rx969_cur) - rx969_fail: -.annotate 'line', 433 - (rx969_rep, rx969_pos, $I10, $P10) = rx969_cur."!mark_fail"(0) - lt rx969_pos, -1, rx969_done - eq rx969_pos, -1, rx969_fail + rx971_cur."!cursor_pass"(rx971_pos, "infixish") + rx971_cur."!cursor_debug"("PASS ", "infixish", " at pos=", rx971_pos) + .return (rx971_cur) + rx971_fail: +.annotate 'line', 445 + (rx971_rep, rx971_pos, $I10, $P10) = rx971_cur."!mark_fail"(0) + lt rx971_pos, -1, rx971_done + eq rx971_pos, -1, rx971_fail jump $I10 - rx969_done: - rx969_cur."!cursor_fail"() - rx969_cur."!cursor_debug"("FAIL ", "postcircumfix:sym<( )>") - .return (rx969_cur) + rx971_done: + rx971_cur."!cursor_fail"() + rx971_cur."!cursor_debug"("FAIL ", "infixish") + .return (rx971_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__postcircumfix:sym<( )>" :subid("240_1275511697.61926") :method -.annotate 'line', 433 - $P971 = self."!PREFIX__!subrule"("", "(") - new $P972, "ResizablePMCArray" - push $P972, $P971 - .return ($P972) +.sub "!PREFIX__infixish" :subid("239_1275600007.84296") :method +.annotate 'line', 445 + new $P973, "ResizablePMCArray" + push $P973, "" + .return ($P973) .end .namespace ["NQP";"Grammar"] -.sub "postfix:sym<.>" :subid("241_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx975_tgt - .local int rx975_pos - .local int rx975_off - .local int rx975_eos - .local int rx975_rep - .local pmc rx975_cur - (rx975_cur, rx975_pos, rx975_tgt) = self."!cursor_start"() - rx975_cur."!cursor_debug"("START ", "postfix:sym<.>") - .lex unicode:"$\x{a2}", rx975_cur +.sub "infixstopper" :subid("240_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx976_tgt + .local int rx976_pos + .local int rx976_off + .local int rx976_eos + .local int rx976_rep + .local pmc rx976_cur + (rx976_cur, rx976_pos, rx976_tgt) = self."!cursor_start"() + rx976_cur."!cursor_debug"("START ", "infixstopper") + .lex unicode:"$\x{a2}", rx976_cur .local pmc match .lex "$/", match - length rx975_eos, rx975_tgt - gt rx975_pos, rx975_eos, rx975_done - set rx975_off, 0 - lt rx975_pos, 2, rx975_start - sub rx975_off, rx975_pos, 1 - substr rx975_tgt, rx975_tgt, rx975_off - rx975_start: + length rx976_eos, rx976_tgt + gt rx976_pos, rx976_eos, rx976_done + set rx976_off, 0 + lt rx976_pos, 2, rx976_start + sub rx976_off, rx976_pos, 1 + substr rx976_tgt, rx976_tgt, rx976_off + rx976_start: $I10 = self.'from'() ne $I10, -1, rxscan979_done goto rxscan979_scan rxscan979_loop: - ($P10) = rx975_cur."from"() + ($P10) = rx976_cur."from"() inc $P10 - set rx975_pos, $P10 - ge rx975_pos, rx975_eos, rxscan979_done + set rx976_pos, $P10 + ge rx976_pos, rx976_eos, rxscan979_done rxscan979_scan: set_addr $I10, rxscan979_loop - rx975_cur."!mark_push"(0, rx975_pos, $I10) + rx976_cur."!mark_push"(0, rx976_pos, $I10) rxscan979_done: -.annotate 'line', 475 - # rx subrule "dotty" subtype=capture negate= - rx975_cur."!cursor_pos"(rx975_pos) - $P10 = rx975_cur."dotty"() - unless $P10, rx975_fail - rx975_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("dotty") - rx975_pos = $P10."pos"() - # rx subrule "O" subtype=capture negate= - rx975_cur."!cursor_pos"(rx975_pos) - $P10 = rx975_cur."O"("%methodop") - unless $P10, rx975_fail - rx975_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("O") - rx975_pos = $P10."pos"() +.annotate 'line', 465 + # rx subrule "lambda" subtype=zerowidth negate= + rx976_cur."!cursor_pos"(rx976_pos) + $P10 = rx976_cur."lambda"() + unless $P10, rx976_fail # rx pass - rx975_cur."!cursor_pass"(rx975_pos, "postfix:sym<.>") - rx975_cur."!cursor_debug"("PASS ", "postfix:sym<.>", " at pos=", rx975_pos) - .return (rx975_cur) - rx975_fail: -.annotate 'line', 433 - (rx975_rep, rx975_pos, $I10, $P10) = rx975_cur."!mark_fail"(0) - lt rx975_pos, -1, rx975_done - eq rx975_pos, -1, rx975_fail + rx976_cur."!cursor_pass"(rx976_pos, "infixstopper") + rx976_cur."!cursor_debug"("PASS ", "infixstopper", " at pos=", rx976_pos) + .return (rx976_cur) + rx976_fail: +.annotate 'line', 445 + (rx976_rep, rx976_pos, $I10, $P10) = rx976_cur."!mark_fail"(0) + lt rx976_pos, -1, rx976_done + eq rx976_pos, -1, rx976_fail jump $I10 - rx975_done: - rx975_cur."!cursor_fail"() - rx975_cur."!cursor_debug"("FAIL ", "postfix:sym<.>") - .return (rx975_cur) + rx976_done: + rx976_cur."!cursor_fail"() + rx976_cur."!cursor_debug"("FAIL ", "infixstopper") + .return (rx976_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__postfix:sym<.>" :subid("242_1275511697.61926") :method -.annotate 'line', 433 - $P977 = self."!PREFIX__!subrule"("dotty", "") +.sub "!PREFIX__infixstopper" :subid("241_1275600007.84296") :method +.annotate 'line', 445 new $P978, "ResizablePMCArray" - push $P978, $P977 + push $P978, "" .return ($P978) .end .namespace ["NQP";"Grammar"] -.sub "prefix:sym<++>" :subid("243_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 +.sub "postcircumfix:sym<[ ]>" :subid("242_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 .local string rx981_tgt .local int rx981_pos .local int rx981_off @@ -12006,7 +11924,7 @@ NQP::Compiler - NQP compiler .local int rx981_rep .local pmc rx981_cur (rx981_cur, rx981_pos, rx981_tgt) = self."!cursor_start"() - rx981_cur."!cursor_debug"("START ", "prefix:sym<++>") + rx981_cur."!cursor_debug"("START ", "postcircumfix:sym<[ ]>") .lex unicode:"$\x{a2}", rx981_cur .local pmc match .lex "$/", match @@ -12029,57 +11947,64 @@ NQP::Compiler - NQP compiler set_addr $I10, rxscan985_loop rx981_cur."!mark_push"(0, rx981_pos, $I10) rxscan985_done: -.annotate 'line', 477 - # rx subcapture "sym" - set_addr $I10, rxcap_986_fail - rx981_cur."!mark_push"(0, rx981_pos, $I10) - # rx literal "++" - add $I11, rx981_pos, 2 +.annotate 'line', 468 + # rx literal "[" + add $I11, rx981_pos, 1 gt $I11, rx981_eos, rx981_fail sub $I11, rx981_pos, rx981_off - substr $S10, rx981_tgt, $I11, 2 - ne $S10, "++", rx981_fail - add rx981_pos, 2 - set_addr $I10, rxcap_986_fail - ($I12, $I11) = rx981_cur."!mark_peek"($I10) - rx981_cur."!cursor_pos"($I11) - ($P10) = rx981_cur."!cursor_start"() - $P10."!cursor_pass"(rx981_pos, "") + substr $S10, rx981_tgt, $I11, 1 + ne $S10, "[", rx981_fail + add rx981_pos, 1 + # rx subrule "ws" subtype=method negate= + rx981_cur."!cursor_pos"(rx981_pos) + $P10 = rx981_cur."ws"() + unless $P10, rx981_fail + rx981_pos = $P10."pos"() + # rx subrule "EXPR" subtype=capture negate= + rx981_cur."!cursor_pos"(rx981_pos) + $P10 = rx981_cur."EXPR"() + unless $P10, rx981_fail rx981_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("sym") - goto rxcap_986_done - rxcap_986_fail: - goto rx981_fail - rxcap_986_done: + $P10."!cursor_names"("EXPR") + rx981_pos = $P10."pos"() + # rx literal "]" + add $I11, rx981_pos, 1 + gt $I11, rx981_eos, rx981_fail + sub $I11, rx981_pos, rx981_off + substr $S10, rx981_tgt, $I11, 1 + ne $S10, "]", rx981_fail + add rx981_pos, 1 +.annotate 'line', 469 # rx subrule "O" subtype=capture negate= rx981_cur."!cursor_pos"(rx981_pos) - $P10 = rx981_cur."O"("%autoincrement, :pirop") + $P10 = rx981_cur."O"("%methodop") unless $P10, rx981_fail rx981_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") rx981_pos = $P10."pos"() +.annotate 'line', 467 # rx pass - rx981_cur."!cursor_pass"(rx981_pos, "prefix:sym<++>") - rx981_cur."!cursor_debug"("PASS ", "prefix:sym<++>", " at pos=", rx981_pos) + rx981_cur."!cursor_pass"(rx981_pos, "postcircumfix:sym<[ ]>") + rx981_cur."!cursor_debug"("PASS ", "postcircumfix:sym<[ ]>", " at pos=", rx981_pos) .return (rx981_cur) rx981_fail: -.annotate 'line', 433 +.annotate 'line', 445 (rx981_rep, rx981_pos, $I10, $P10) = rx981_cur."!mark_fail"(0) lt rx981_pos, -1, rx981_done eq rx981_pos, -1, rx981_fail jump $I10 rx981_done: rx981_cur."!cursor_fail"() - rx981_cur."!cursor_debug"("FAIL ", "prefix:sym<++>") + rx981_cur."!cursor_debug"("FAIL ", "postcircumfix:sym<[ ]>") .return (rx981_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__prefix:sym<++>" :subid("244_1275511697.61926") :method -.annotate 'line', 433 - $P983 = self."!PREFIX__!subrule"("O", "++") +.sub "!PREFIX__postcircumfix:sym<[ ]>" :subid("243_1275600007.84296") :method +.annotate 'line', 445 + $P983 = self."!PREFIX__!subrule"("", "[") new $P984, "ResizablePMCArray" push $P984, $P983 .return ($P984) @@ -12087,4564 +12012,4556 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Grammar"] -.sub "prefix:sym<-->" :subid("245_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx988_tgt - .local int rx988_pos - .local int rx988_off - .local int rx988_eos - .local int rx988_rep - .local pmc rx988_cur - (rx988_cur, rx988_pos, rx988_tgt) = self."!cursor_start"() - rx988_cur."!cursor_debug"("START ", "prefix:sym<-->") - .lex unicode:"$\x{a2}", rx988_cur +.sub "postcircumfix:sym<{ }>" :subid("244_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx987_tgt + .local int rx987_pos + .local int rx987_off + .local int rx987_eos + .local int rx987_rep + .local pmc rx987_cur + (rx987_cur, rx987_pos, rx987_tgt) = self."!cursor_start"() + rx987_cur."!cursor_debug"("START ", "postcircumfix:sym<{ }>") + .lex unicode:"$\x{a2}", rx987_cur .local pmc match .lex "$/", match - length rx988_eos, rx988_tgt - gt rx988_pos, rx988_eos, rx988_done - set rx988_off, 0 - lt rx988_pos, 2, rx988_start - sub rx988_off, rx988_pos, 1 - substr rx988_tgt, rx988_tgt, rx988_off - rx988_start: + length rx987_eos, rx987_tgt + gt rx987_pos, rx987_eos, rx987_done + set rx987_off, 0 + lt rx987_pos, 2, rx987_start + sub rx987_off, rx987_pos, 1 + substr rx987_tgt, rx987_tgt, rx987_off + rx987_start: $I10 = self.'from'() - ne $I10, -1, rxscan992_done - goto rxscan992_scan - rxscan992_loop: - ($P10) = rx988_cur."from"() + ne $I10, -1, rxscan991_done + goto rxscan991_scan + rxscan991_loop: + ($P10) = rx987_cur."from"() inc $P10 - set rx988_pos, $P10 - ge rx988_pos, rx988_eos, rxscan992_done - rxscan992_scan: - set_addr $I10, rxscan992_loop - rx988_cur."!mark_push"(0, rx988_pos, $I10) - rxscan992_done: -.annotate 'line', 478 - # rx subcapture "sym" - set_addr $I10, rxcap_993_fail - rx988_cur."!mark_push"(0, rx988_pos, $I10) - # rx literal "--" - add $I11, rx988_pos, 2 - gt $I11, rx988_eos, rx988_fail - sub $I11, rx988_pos, rx988_off - substr $S10, rx988_tgt, $I11, 2 - ne $S10, "--", rx988_fail - add rx988_pos, 2 - set_addr $I10, rxcap_993_fail - ($I12, $I11) = rx988_cur."!mark_peek"($I10) - rx988_cur."!cursor_pos"($I11) - ($P10) = rx988_cur."!cursor_start"() - $P10."!cursor_pass"(rx988_pos, "") - rx988_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("sym") - goto rxcap_993_done - rxcap_993_fail: - goto rx988_fail - rxcap_993_done: + set rx987_pos, $P10 + ge rx987_pos, rx987_eos, rxscan991_done + rxscan991_scan: + set_addr $I10, rxscan991_loop + rx987_cur."!mark_push"(0, rx987_pos, $I10) + rxscan991_done: +.annotate 'line', 473 + # rx literal "{" + add $I11, rx987_pos, 1 + gt $I11, rx987_eos, rx987_fail + sub $I11, rx987_pos, rx987_off + substr $S10, rx987_tgt, $I11, 1 + ne $S10, "{", rx987_fail + add rx987_pos, 1 + # rx subrule "ws" subtype=method negate= + rx987_cur."!cursor_pos"(rx987_pos) + $P10 = rx987_cur."ws"() + unless $P10, rx987_fail + rx987_pos = $P10."pos"() + # rx subrule "EXPR" subtype=capture negate= + rx987_cur."!cursor_pos"(rx987_pos) + $P10 = rx987_cur."EXPR"() + unless $P10, rx987_fail + rx987_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("EXPR") + rx987_pos = $P10."pos"() + # rx literal "}" + add $I11, rx987_pos, 1 + gt $I11, rx987_eos, rx987_fail + sub $I11, rx987_pos, rx987_off + substr $S10, rx987_tgt, $I11, 1 + ne $S10, "}", rx987_fail + add rx987_pos, 1 +.annotate 'line', 474 # rx subrule "O" subtype=capture negate= - rx988_cur."!cursor_pos"(rx988_pos) - $P10 = rx988_cur."O"("%autoincrement, :pirop") - unless $P10, rx988_fail - rx988_cur."!mark_push"(0, -1, 0, $P10) + rx987_cur."!cursor_pos"(rx987_pos) + $P10 = rx987_cur."O"("%methodop") + unless $P10, rx987_fail + rx987_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx988_pos = $P10."pos"() + rx987_pos = $P10."pos"() +.annotate 'line', 472 # rx pass - rx988_cur."!cursor_pass"(rx988_pos, "prefix:sym<-->") - rx988_cur."!cursor_debug"("PASS ", "prefix:sym<-->", " at pos=", rx988_pos) - .return (rx988_cur) - rx988_fail: -.annotate 'line', 433 - (rx988_rep, rx988_pos, $I10, $P10) = rx988_cur."!mark_fail"(0) - lt rx988_pos, -1, rx988_done - eq rx988_pos, -1, rx988_fail + rx987_cur."!cursor_pass"(rx987_pos, "postcircumfix:sym<{ }>") + rx987_cur."!cursor_debug"("PASS ", "postcircumfix:sym<{ }>", " at pos=", rx987_pos) + .return (rx987_cur) + rx987_fail: +.annotate 'line', 445 + (rx987_rep, rx987_pos, $I10, $P10) = rx987_cur."!mark_fail"(0) + lt rx987_pos, -1, rx987_done + eq rx987_pos, -1, rx987_fail jump $I10 - rx988_done: - rx988_cur."!cursor_fail"() - rx988_cur."!cursor_debug"("FAIL ", "prefix:sym<-->") - .return (rx988_cur) + rx987_done: + rx987_cur."!cursor_fail"() + rx987_cur."!cursor_debug"("FAIL ", "postcircumfix:sym<{ }>") + .return (rx987_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__prefix:sym<-->" :subid("246_1275511697.61926") :method -.annotate 'line', 433 - $P990 = self."!PREFIX__!subrule"("O", "--") - new $P991, "ResizablePMCArray" - push $P991, $P990 - .return ($P991) +.sub "!PREFIX__postcircumfix:sym<{ }>" :subid("245_1275600007.84296") :method +.annotate 'line', 445 + $P989 = self."!PREFIX__!subrule"("", "{") + new $P990, "ResizablePMCArray" + push $P990, $P989 + .return ($P990) .end .namespace ["NQP";"Grammar"] -.sub "postfix:sym<++>" :subid("247_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx995_tgt - .local int rx995_pos - .local int rx995_off - .local int rx995_eos - .local int rx995_rep - .local pmc rx995_cur - (rx995_cur, rx995_pos, rx995_tgt) = self."!cursor_start"() - rx995_cur."!cursor_debug"("START ", "postfix:sym<++>") - .lex unicode:"$\x{a2}", rx995_cur +.sub "postcircumfix:sym" :subid("246_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx993_tgt + .local int rx993_pos + .local int rx993_off + .local int rx993_eos + .local int rx993_rep + .local pmc rx993_cur + (rx993_cur, rx993_pos, rx993_tgt) = self."!cursor_start"() + rx993_cur."!cursor_debug"("START ", "postcircumfix:sym") + .lex unicode:"$\x{a2}", rx993_cur .local pmc match .lex "$/", match - length rx995_eos, rx995_tgt - gt rx995_pos, rx995_eos, rx995_done - set rx995_off, 0 - lt rx995_pos, 2, rx995_start - sub rx995_off, rx995_pos, 1 - substr rx995_tgt, rx995_tgt, rx995_off - rx995_start: + length rx993_eos, rx993_tgt + gt rx993_pos, rx993_eos, rx993_done + set rx993_off, 0 + lt rx993_pos, 2, rx993_start + sub rx993_off, rx993_pos, 1 + substr rx993_tgt, rx993_tgt, rx993_off + rx993_start: $I10 = self.'from'() - ne $I10, -1, rxscan999_done - goto rxscan999_scan - rxscan999_loop: - ($P10) = rx995_cur."from"() + ne $I10, -1, rxscan996_done + goto rxscan996_scan + rxscan996_loop: + ($P10) = rx993_cur."from"() inc $P10 - set rx995_pos, $P10 - ge rx995_pos, rx995_eos, rxscan999_done - rxscan999_scan: - set_addr $I10, rxscan999_loop - rx995_cur."!mark_push"(0, rx995_pos, $I10) - rxscan999_done: -.annotate 'line', 481 - # rx subcapture "sym" - set_addr $I10, rxcap_1000_fail - rx995_cur."!mark_push"(0, rx995_pos, $I10) - # rx literal "++" - add $I11, rx995_pos, 2 - gt $I11, rx995_eos, rx995_fail - sub $I11, rx995_pos, rx995_off - substr $S10, rx995_tgt, $I11, 2 - ne $S10, "++", rx995_fail - add rx995_pos, 2 - set_addr $I10, rxcap_1000_fail - ($I12, $I11) = rx995_cur."!mark_peek"($I10) - rx995_cur."!cursor_pos"($I11) - ($P10) = rx995_cur."!cursor_start"() - $P10."!cursor_pass"(rx995_pos, "") - rx995_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("sym") - goto rxcap_1000_done - rxcap_1000_fail: - goto rx995_fail - rxcap_1000_done: + set rx993_pos, $P10 + ge rx993_pos, rx993_eos, rxscan996_done + rxscan996_scan: + set_addr $I10, rxscan996_loop + rx993_cur."!mark_push"(0, rx993_pos, $I10) + rxscan996_done: +.annotate 'line', 478 + # rx enumcharlist negate=0 zerowidth + ge rx993_pos, rx993_eos, rx993_fail + sub $I10, rx993_pos, rx993_off + substr $S10, rx993_tgt, $I10, 1 + index $I11, "<", $S10 + lt $I11, 0, rx993_fail + # rx subrule "quote_EXPR" subtype=capture negate= + rx993_cur."!cursor_pos"(rx993_pos) + $P10 = rx993_cur."quote_EXPR"(":q") + unless $P10, rx993_fail + rx993_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("quote_EXPR") + rx993_pos = $P10."pos"() +.annotate 'line', 479 # rx subrule "O" subtype=capture negate= - rx995_cur."!cursor_pos"(rx995_pos) - $P10 = rx995_cur."O"("%autoincrement") - unless $P10, rx995_fail - rx995_cur."!mark_push"(0, -1, 0, $P10) + rx993_cur."!cursor_pos"(rx993_pos) + $P10 = rx993_cur."O"("%methodop") + unless $P10, rx993_fail + rx993_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx995_pos = $P10."pos"() + rx993_pos = $P10."pos"() +.annotate 'line', 477 # rx pass - rx995_cur."!cursor_pass"(rx995_pos, "postfix:sym<++>") - rx995_cur."!cursor_debug"("PASS ", "postfix:sym<++>", " at pos=", rx995_pos) - .return (rx995_cur) - rx995_fail: -.annotate 'line', 433 - (rx995_rep, rx995_pos, $I10, $P10) = rx995_cur."!mark_fail"(0) - lt rx995_pos, -1, rx995_done - eq rx995_pos, -1, rx995_fail + rx993_cur."!cursor_pass"(rx993_pos, "postcircumfix:sym") + rx993_cur."!cursor_debug"("PASS ", "postcircumfix:sym", " at pos=", rx993_pos) + .return (rx993_cur) + rx993_fail: +.annotate 'line', 445 + (rx993_rep, rx993_pos, $I10, $P10) = rx993_cur."!mark_fail"(0) + lt rx993_pos, -1, rx993_done + eq rx993_pos, -1, rx993_fail jump $I10 - rx995_done: - rx995_cur."!cursor_fail"() - rx995_cur."!cursor_debug"("FAIL ", "postfix:sym<++>") - .return (rx995_cur) + rx993_done: + rx993_cur."!cursor_fail"() + rx993_cur."!cursor_debug"("FAIL ", "postcircumfix:sym") + .return (rx993_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__postfix:sym<++>" :subid("248_1275511697.61926") :method -.annotate 'line', 433 - $P997 = self."!PREFIX__!subrule"("O", "++") - new $P998, "ResizablePMCArray" - push $P998, $P997 - .return ($P998) +.sub "!PREFIX__postcircumfix:sym" :subid("247_1275600007.84296") :method +.annotate 'line', 445 + new $P995, "ResizablePMCArray" + push $P995, "<" + .return ($P995) .end .namespace ["NQP";"Grammar"] -.sub "postfix:sym<-->" :subid("249_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1002_tgt - .local int rx1002_pos - .local int rx1002_off - .local int rx1002_eos - .local int rx1002_rep - .local pmc rx1002_cur - (rx1002_cur, rx1002_pos, rx1002_tgt) = self."!cursor_start"() - rx1002_cur."!cursor_debug"("START ", "postfix:sym<-->") - .lex unicode:"$\x{a2}", rx1002_cur +.sub "postcircumfix:sym<( )>" :subid("248_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx998_tgt + .local int rx998_pos + .local int rx998_off + .local int rx998_eos + .local int rx998_rep + .local pmc rx998_cur + (rx998_cur, rx998_pos, rx998_tgt) = self."!cursor_start"() + rx998_cur."!cursor_debug"("START ", "postcircumfix:sym<( )>") + .lex unicode:"$\x{a2}", rx998_cur .local pmc match .lex "$/", match - length rx1002_eos, rx1002_tgt - gt rx1002_pos, rx1002_eos, rx1002_done - set rx1002_off, 0 - lt rx1002_pos, 2, rx1002_start - sub rx1002_off, rx1002_pos, 1 - substr rx1002_tgt, rx1002_tgt, rx1002_off - rx1002_start: + length rx998_eos, rx998_tgt + gt rx998_pos, rx998_eos, rx998_done + set rx998_off, 0 + lt rx998_pos, 2, rx998_start + sub rx998_off, rx998_pos, 1 + substr rx998_tgt, rx998_tgt, rx998_off + rx998_start: $I10 = self.'from'() - ne $I10, -1, rxscan1006_done - goto rxscan1006_scan - rxscan1006_loop: - ($P10) = rx1002_cur."from"() + ne $I10, -1, rxscan1002_done + goto rxscan1002_scan + rxscan1002_loop: + ($P10) = rx998_cur."from"() inc $P10 - set rx1002_pos, $P10 - ge rx1002_pos, rx1002_eos, rxscan1006_done - rxscan1006_scan: - set_addr $I10, rxscan1006_loop - rx1002_cur."!mark_push"(0, rx1002_pos, $I10) - rxscan1006_done: -.annotate 'line', 482 - # rx subcapture "sym" - set_addr $I10, rxcap_1007_fail - rx1002_cur."!mark_push"(0, rx1002_pos, $I10) - # rx literal "--" - add $I11, rx1002_pos, 2 - gt $I11, rx1002_eos, rx1002_fail - sub $I11, rx1002_pos, rx1002_off - substr $S10, rx1002_tgt, $I11, 2 - ne $S10, "--", rx1002_fail - add rx1002_pos, 2 - set_addr $I10, rxcap_1007_fail - ($I12, $I11) = rx1002_cur."!mark_peek"($I10) - rx1002_cur."!cursor_pos"($I11) - ($P10) = rx1002_cur."!cursor_start"() - $P10."!cursor_pass"(rx1002_pos, "") - rx1002_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("sym") - goto rxcap_1007_done - rxcap_1007_fail: - goto rx1002_fail - rxcap_1007_done: + set rx998_pos, $P10 + ge rx998_pos, rx998_eos, rxscan1002_done + rxscan1002_scan: + set_addr $I10, rxscan1002_loop + rx998_cur."!mark_push"(0, rx998_pos, $I10) + rxscan1002_done: +.annotate 'line', 483 + # rx literal "(" + add $I11, rx998_pos, 1 + gt $I11, rx998_eos, rx998_fail + sub $I11, rx998_pos, rx998_off + substr $S10, rx998_tgt, $I11, 1 + ne $S10, "(", rx998_fail + add rx998_pos, 1 + # rx subrule "ws" subtype=method negate= + rx998_cur."!cursor_pos"(rx998_pos) + $P10 = rx998_cur."ws"() + unless $P10, rx998_fail + rx998_pos = $P10."pos"() + # rx subrule "arglist" subtype=capture negate= + rx998_cur."!cursor_pos"(rx998_pos) + $P10 = rx998_cur."arglist"() + unless $P10, rx998_fail + rx998_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("arglist") + rx998_pos = $P10."pos"() + # rx literal ")" + add $I11, rx998_pos, 1 + gt $I11, rx998_eos, rx998_fail + sub $I11, rx998_pos, rx998_off + substr $S10, rx998_tgt, $I11, 1 + ne $S10, ")", rx998_fail + add rx998_pos, 1 +.annotate 'line', 484 # rx subrule "O" subtype=capture negate= - rx1002_cur."!cursor_pos"(rx1002_pos) - $P10 = rx1002_cur."O"("%autoincrement") - unless $P10, rx1002_fail - rx1002_cur."!mark_push"(0, -1, 0, $P10) + rx998_cur."!cursor_pos"(rx998_pos) + $P10 = rx998_cur."O"("%methodop") + unless $P10, rx998_fail + rx998_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1002_pos = $P10."pos"() + rx998_pos = $P10."pos"() +.annotate 'line', 482 # rx pass - rx1002_cur."!cursor_pass"(rx1002_pos, "postfix:sym<-->") - rx1002_cur."!cursor_debug"("PASS ", "postfix:sym<-->", " at pos=", rx1002_pos) - .return (rx1002_cur) - rx1002_fail: -.annotate 'line', 433 - (rx1002_rep, rx1002_pos, $I10, $P10) = rx1002_cur."!mark_fail"(0) - lt rx1002_pos, -1, rx1002_done - eq rx1002_pos, -1, rx1002_fail + rx998_cur."!cursor_pass"(rx998_pos, "postcircumfix:sym<( )>") + rx998_cur."!cursor_debug"("PASS ", "postcircumfix:sym<( )>", " at pos=", rx998_pos) + .return (rx998_cur) + rx998_fail: +.annotate 'line', 445 + (rx998_rep, rx998_pos, $I10, $P10) = rx998_cur."!mark_fail"(0) + lt rx998_pos, -1, rx998_done + eq rx998_pos, -1, rx998_fail jump $I10 - rx1002_done: - rx1002_cur."!cursor_fail"() - rx1002_cur."!cursor_debug"("FAIL ", "postfix:sym<-->") - .return (rx1002_cur) + rx998_done: + rx998_cur."!cursor_fail"() + rx998_cur."!cursor_debug"("FAIL ", "postcircumfix:sym<( )>") + .return (rx998_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__postfix:sym<-->" :subid("250_1275511697.61926") :method -.annotate 'line', 433 - $P1004 = self."!PREFIX__!subrule"("O", "--") - new $P1005, "ResizablePMCArray" - push $P1005, $P1004 - .return ($P1005) +.sub "!PREFIX__postcircumfix:sym<( )>" :subid("249_1275600007.84296") :method +.annotate 'line', 445 + $P1000 = self."!PREFIX__!subrule"("", "(") + new $P1001, "ResizablePMCArray" + push $P1001, $P1000 + .return ($P1001) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<**>" :subid("251_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1009_tgt - .local int rx1009_pos - .local int rx1009_off - .local int rx1009_eos - .local int rx1009_rep - .local pmc rx1009_cur - (rx1009_cur, rx1009_pos, rx1009_tgt) = self."!cursor_start"() - rx1009_cur."!cursor_debug"("START ", "infix:sym<**>") - .lex unicode:"$\x{a2}", rx1009_cur +.sub "postfix:sym<.>" :subid("250_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1004_tgt + .local int rx1004_pos + .local int rx1004_off + .local int rx1004_eos + .local int rx1004_rep + .local pmc rx1004_cur + (rx1004_cur, rx1004_pos, rx1004_tgt) = self."!cursor_start"() + rx1004_cur."!cursor_debug"("START ", "postfix:sym<.>") + .lex unicode:"$\x{a2}", rx1004_cur .local pmc match .lex "$/", match - length rx1009_eos, rx1009_tgt - gt rx1009_pos, rx1009_eos, rx1009_done - set rx1009_off, 0 - lt rx1009_pos, 2, rx1009_start - sub rx1009_off, rx1009_pos, 1 - substr rx1009_tgt, rx1009_tgt, rx1009_off - rx1009_start: + length rx1004_eos, rx1004_tgt + gt rx1004_pos, rx1004_eos, rx1004_done + set rx1004_off, 0 + lt rx1004_pos, 2, rx1004_start + sub rx1004_off, rx1004_pos, 1 + substr rx1004_tgt, rx1004_tgt, rx1004_off + rx1004_start: $I10 = self.'from'() - ne $I10, -1, rxscan1013_done - goto rxscan1013_scan - rxscan1013_loop: - ($P10) = rx1009_cur."from"() + ne $I10, -1, rxscan1008_done + goto rxscan1008_scan + rxscan1008_loop: + ($P10) = rx1004_cur."from"() inc $P10 - set rx1009_pos, $P10 - ge rx1009_pos, rx1009_eos, rxscan1013_done - rxscan1013_scan: - set_addr $I10, rxscan1013_loop - rx1009_cur."!mark_push"(0, rx1009_pos, $I10) - rxscan1013_done: -.annotate 'line', 484 - # rx subcapture "sym" - set_addr $I10, rxcap_1014_fail - rx1009_cur."!mark_push"(0, rx1009_pos, $I10) - # rx literal "**" - add $I11, rx1009_pos, 2 - gt $I11, rx1009_eos, rx1009_fail - sub $I11, rx1009_pos, rx1009_off - substr $S10, rx1009_tgt, $I11, 2 - ne $S10, "**", rx1009_fail - add rx1009_pos, 2 - set_addr $I10, rxcap_1014_fail - ($I12, $I11) = rx1009_cur."!mark_peek"($I10) - rx1009_cur."!cursor_pos"($I11) - ($P10) = rx1009_cur."!cursor_start"() - $P10."!cursor_pass"(rx1009_pos, "") - rx1009_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("sym") - goto rxcap_1014_done - rxcap_1014_fail: - goto rx1009_fail - rxcap_1014_done: + set rx1004_pos, $P10 + ge rx1004_pos, rx1004_eos, rxscan1008_done + rxscan1008_scan: + set_addr $I10, rxscan1008_loop + rx1004_cur."!mark_push"(0, rx1004_pos, $I10) + rxscan1008_done: +.annotate 'line', 487 + # rx subrule "dotty" subtype=capture negate= + rx1004_cur."!cursor_pos"(rx1004_pos) + $P10 = rx1004_cur."dotty"() + unless $P10, rx1004_fail + rx1004_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("dotty") + rx1004_pos = $P10."pos"() # rx subrule "O" subtype=capture negate= - rx1009_cur."!cursor_pos"(rx1009_pos) - $P10 = rx1009_cur."O"("%exponentiation, :pirop") - unless $P10, rx1009_fail - rx1009_cur."!mark_push"(0, -1, 0, $P10) + rx1004_cur."!cursor_pos"(rx1004_pos) + $P10 = rx1004_cur."O"("%methodop") + unless $P10, rx1004_fail + rx1004_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1009_pos = $P10."pos"() + rx1004_pos = $P10."pos"() # rx pass - rx1009_cur."!cursor_pass"(rx1009_pos, "infix:sym<**>") - rx1009_cur."!cursor_debug"("PASS ", "infix:sym<**>", " at pos=", rx1009_pos) - .return (rx1009_cur) - rx1009_fail: -.annotate 'line', 433 - (rx1009_rep, rx1009_pos, $I10, $P10) = rx1009_cur."!mark_fail"(0) - lt rx1009_pos, -1, rx1009_done - eq rx1009_pos, -1, rx1009_fail + rx1004_cur."!cursor_pass"(rx1004_pos, "postfix:sym<.>") + rx1004_cur."!cursor_debug"("PASS ", "postfix:sym<.>", " at pos=", rx1004_pos) + .return (rx1004_cur) + rx1004_fail: +.annotate 'line', 445 + (rx1004_rep, rx1004_pos, $I10, $P10) = rx1004_cur."!mark_fail"(0) + lt rx1004_pos, -1, rx1004_done + eq rx1004_pos, -1, rx1004_fail jump $I10 - rx1009_done: - rx1009_cur."!cursor_fail"() - rx1009_cur."!cursor_debug"("FAIL ", "infix:sym<**>") - .return (rx1009_cur) + rx1004_done: + rx1004_cur."!cursor_fail"() + rx1004_cur."!cursor_debug"("FAIL ", "postfix:sym<.>") + .return (rx1004_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<**>" :subid("252_1275511697.61926") :method -.annotate 'line', 433 - $P1011 = self."!PREFIX__!subrule"("O", "**") - new $P1012, "ResizablePMCArray" - push $P1012, $P1011 - .return ($P1012) +.sub "!PREFIX__postfix:sym<.>" :subid("251_1275600007.84296") :method +.annotate 'line', 445 + $P1006 = self."!PREFIX__!subrule"("dotty", "") + new $P1007, "ResizablePMCArray" + push $P1007, $P1006 + .return ($P1007) .end .namespace ["NQP";"Grammar"] -.sub "prefix:sym<+>" :subid("253_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1016_tgt - .local int rx1016_pos - .local int rx1016_off - .local int rx1016_eos - .local int rx1016_rep - .local pmc rx1016_cur - (rx1016_cur, rx1016_pos, rx1016_tgt) = self."!cursor_start"() - rx1016_cur."!cursor_debug"("START ", "prefix:sym<+>") - .lex unicode:"$\x{a2}", rx1016_cur +.sub "prefix:sym<++>" :subid("252_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1010_tgt + .local int rx1010_pos + .local int rx1010_off + .local int rx1010_eos + .local int rx1010_rep + .local pmc rx1010_cur + (rx1010_cur, rx1010_pos, rx1010_tgt) = self."!cursor_start"() + rx1010_cur."!cursor_debug"("START ", "prefix:sym<++>") + .lex unicode:"$\x{a2}", rx1010_cur .local pmc match .lex "$/", match - length rx1016_eos, rx1016_tgt - gt rx1016_pos, rx1016_eos, rx1016_done - set rx1016_off, 0 - lt rx1016_pos, 2, rx1016_start - sub rx1016_off, rx1016_pos, 1 - substr rx1016_tgt, rx1016_tgt, rx1016_off - rx1016_start: + length rx1010_eos, rx1010_tgt + gt rx1010_pos, rx1010_eos, rx1010_done + set rx1010_off, 0 + lt rx1010_pos, 2, rx1010_start + sub rx1010_off, rx1010_pos, 1 + substr rx1010_tgt, rx1010_tgt, rx1010_off + rx1010_start: $I10 = self.'from'() - ne $I10, -1, rxscan1020_done - goto rxscan1020_scan - rxscan1020_loop: - ($P10) = rx1016_cur."from"() + ne $I10, -1, rxscan1014_done + goto rxscan1014_scan + rxscan1014_loop: + ($P10) = rx1010_cur."from"() inc $P10 - set rx1016_pos, $P10 - ge rx1016_pos, rx1016_eos, rxscan1020_done - rxscan1020_scan: - set_addr $I10, rxscan1020_loop - rx1016_cur."!mark_push"(0, rx1016_pos, $I10) - rxscan1020_done: -.annotate 'line', 486 + set rx1010_pos, $P10 + ge rx1010_pos, rx1010_eos, rxscan1014_done + rxscan1014_scan: + set_addr $I10, rxscan1014_loop + rx1010_cur."!mark_push"(0, rx1010_pos, $I10) + rxscan1014_done: +.annotate 'line', 489 # rx subcapture "sym" - set_addr $I10, rxcap_1021_fail - rx1016_cur."!mark_push"(0, rx1016_pos, $I10) - # rx literal "+" - add $I11, rx1016_pos, 1 - gt $I11, rx1016_eos, rx1016_fail - sub $I11, rx1016_pos, rx1016_off - substr $S10, rx1016_tgt, $I11, 1 - ne $S10, "+", rx1016_fail - add rx1016_pos, 1 - set_addr $I10, rxcap_1021_fail - ($I12, $I11) = rx1016_cur."!mark_peek"($I10) - rx1016_cur."!cursor_pos"($I11) - ($P10) = rx1016_cur."!cursor_start"() - $P10."!cursor_pass"(rx1016_pos, "") - rx1016_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1015_fail + rx1010_cur."!mark_push"(0, rx1010_pos, $I10) + # rx literal "++" + add $I11, rx1010_pos, 2 + gt $I11, rx1010_eos, rx1010_fail + sub $I11, rx1010_pos, rx1010_off + substr $S10, rx1010_tgt, $I11, 2 + ne $S10, "++", rx1010_fail + add rx1010_pos, 2 + set_addr $I10, rxcap_1015_fail + ($I12, $I11) = rx1010_cur."!mark_peek"($I10) + rx1010_cur."!cursor_pos"($I11) + ($P10) = rx1010_cur."!cursor_start"() + $P10."!cursor_pass"(rx1010_pos, "") + rx1010_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1021_done - rxcap_1021_fail: - goto rx1016_fail - rxcap_1021_done: + goto rxcap_1015_done + rxcap_1015_fail: + goto rx1010_fail + rxcap_1015_done: # rx subrule "O" subtype=capture negate= - rx1016_cur."!cursor_pos"(rx1016_pos) - $P10 = rx1016_cur."O"("%symbolic_unary, :pirop") - unless $P10, rx1016_fail - rx1016_cur."!mark_push"(0, -1, 0, $P10) + rx1010_cur."!cursor_pos"(rx1010_pos) + $P10 = rx1010_cur."O"("%autoincrement, :pirop") + unless $P10, rx1010_fail + rx1010_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1016_pos = $P10."pos"() + rx1010_pos = $P10."pos"() # rx pass - rx1016_cur."!cursor_pass"(rx1016_pos, "prefix:sym<+>") - rx1016_cur."!cursor_debug"("PASS ", "prefix:sym<+>", " at pos=", rx1016_pos) - .return (rx1016_cur) - rx1016_fail: -.annotate 'line', 433 - (rx1016_rep, rx1016_pos, $I10, $P10) = rx1016_cur."!mark_fail"(0) - lt rx1016_pos, -1, rx1016_done - eq rx1016_pos, -1, rx1016_fail + rx1010_cur."!cursor_pass"(rx1010_pos, "prefix:sym<++>") + rx1010_cur."!cursor_debug"("PASS ", "prefix:sym<++>", " at pos=", rx1010_pos) + .return (rx1010_cur) + rx1010_fail: +.annotate 'line', 445 + (rx1010_rep, rx1010_pos, $I10, $P10) = rx1010_cur."!mark_fail"(0) + lt rx1010_pos, -1, rx1010_done + eq rx1010_pos, -1, rx1010_fail jump $I10 - rx1016_done: - rx1016_cur."!cursor_fail"() - rx1016_cur."!cursor_debug"("FAIL ", "prefix:sym<+>") - .return (rx1016_cur) + rx1010_done: + rx1010_cur."!cursor_fail"() + rx1010_cur."!cursor_debug"("FAIL ", "prefix:sym<++>") + .return (rx1010_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__prefix:sym<+>" :subid("254_1275511697.61926") :method -.annotate 'line', 433 - $P1018 = self."!PREFIX__!subrule"("O", "+") - new $P1019, "ResizablePMCArray" - push $P1019, $P1018 - .return ($P1019) +.sub "!PREFIX__prefix:sym<++>" :subid("253_1275600007.84296") :method +.annotate 'line', 445 + $P1012 = self."!PREFIX__!subrule"("O", "++") + new $P1013, "ResizablePMCArray" + push $P1013, $P1012 + .return ($P1013) .end .namespace ["NQP";"Grammar"] -.sub "prefix:sym<~>" :subid("255_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1023_tgt - .local int rx1023_pos - .local int rx1023_off - .local int rx1023_eos - .local int rx1023_rep - .local pmc rx1023_cur - (rx1023_cur, rx1023_pos, rx1023_tgt) = self."!cursor_start"() - rx1023_cur."!cursor_debug"("START ", "prefix:sym<~>") - .lex unicode:"$\x{a2}", rx1023_cur +.sub "prefix:sym<-->" :subid("254_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1017_tgt + .local int rx1017_pos + .local int rx1017_off + .local int rx1017_eos + .local int rx1017_rep + .local pmc rx1017_cur + (rx1017_cur, rx1017_pos, rx1017_tgt) = self."!cursor_start"() + rx1017_cur."!cursor_debug"("START ", "prefix:sym<-->") + .lex unicode:"$\x{a2}", rx1017_cur .local pmc match .lex "$/", match - length rx1023_eos, rx1023_tgt - gt rx1023_pos, rx1023_eos, rx1023_done - set rx1023_off, 0 - lt rx1023_pos, 2, rx1023_start - sub rx1023_off, rx1023_pos, 1 - substr rx1023_tgt, rx1023_tgt, rx1023_off - rx1023_start: + length rx1017_eos, rx1017_tgt + gt rx1017_pos, rx1017_eos, rx1017_done + set rx1017_off, 0 + lt rx1017_pos, 2, rx1017_start + sub rx1017_off, rx1017_pos, 1 + substr rx1017_tgt, rx1017_tgt, rx1017_off + rx1017_start: $I10 = self.'from'() - ne $I10, -1, rxscan1027_done - goto rxscan1027_scan - rxscan1027_loop: - ($P10) = rx1023_cur."from"() + ne $I10, -1, rxscan1021_done + goto rxscan1021_scan + rxscan1021_loop: + ($P10) = rx1017_cur."from"() inc $P10 - set rx1023_pos, $P10 - ge rx1023_pos, rx1023_eos, rxscan1027_done - rxscan1027_scan: - set_addr $I10, rxscan1027_loop - rx1023_cur."!mark_push"(0, rx1023_pos, $I10) - rxscan1027_done: -.annotate 'line', 487 + set rx1017_pos, $P10 + ge rx1017_pos, rx1017_eos, rxscan1021_done + rxscan1021_scan: + set_addr $I10, rxscan1021_loop + rx1017_cur."!mark_push"(0, rx1017_pos, $I10) + rxscan1021_done: +.annotate 'line', 490 # rx subcapture "sym" - set_addr $I10, rxcap_1028_fail - rx1023_cur."!mark_push"(0, rx1023_pos, $I10) - # rx literal "~" - add $I11, rx1023_pos, 1 - gt $I11, rx1023_eos, rx1023_fail - sub $I11, rx1023_pos, rx1023_off - substr $S10, rx1023_tgt, $I11, 1 - ne $S10, "~", rx1023_fail - add rx1023_pos, 1 - set_addr $I10, rxcap_1028_fail - ($I12, $I11) = rx1023_cur."!mark_peek"($I10) - rx1023_cur."!cursor_pos"($I11) - ($P10) = rx1023_cur."!cursor_start"() - $P10."!cursor_pass"(rx1023_pos, "") - rx1023_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1022_fail + rx1017_cur."!mark_push"(0, rx1017_pos, $I10) + # rx literal "--" + add $I11, rx1017_pos, 2 + gt $I11, rx1017_eos, rx1017_fail + sub $I11, rx1017_pos, rx1017_off + substr $S10, rx1017_tgt, $I11, 2 + ne $S10, "--", rx1017_fail + add rx1017_pos, 2 + set_addr $I10, rxcap_1022_fail + ($I12, $I11) = rx1017_cur."!mark_peek"($I10) + rx1017_cur."!cursor_pos"($I11) + ($P10) = rx1017_cur."!cursor_start"() + $P10."!cursor_pass"(rx1017_pos, "") + rx1017_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1028_done - rxcap_1028_fail: - goto rx1023_fail - rxcap_1028_done: + goto rxcap_1022_done + rxcap_1022_fail: + goto rx1017_fail + rxcap_1022_done: # rx subrule "O" subtype=capture negate= - rx1023_cur."!cursor_pos"(rx1023_pos) - $P10 = rx1023_cur."O"("%symbolic_unary, :pirop") - unless $P10, rx1023_fail - rx1023_cur."!mark_push"(0, -1, 0, $P10) + rx1017_cur."!cursor_pos"(rx1017_pos) + $P10 = rx1017_cur."O"("%autoincrement, :pirop") + unless $P10, rx1017_fail + rx1017_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1023_pos = $P10."pos"() + rx1017_pos = $P10."pos"() # rx pass - rx1023_cur."!cursor_pass"(rx1023_pos, "prefix:sym<~>") - rx1023_cur."!cursor_debug"("PASS ", "prefix:sym<~>", " at pos=", rx1023_pos) - .return (rx1023_cur) - rx1023_fail: -.annotate 'line', 433 - (rx1023_rep, rx1023_pos, $I10, $P10) = rx1023_cur."!mark_fail"(0) - lt rx1023_pos, -1, rx1023_done - eq rx1023_pos, -1, rx1023_fail + rx1017_cur."!cursor_pass"(rx1017_pos, "prefix:sym<-->") + rx1017_cur."!cursor_debug"("PASS ", "prefix:sym<-->", " at pos=", rx1017_pos) + .return (rx1017_cur) + rx1017_fail: +.annotate 'line', 445 + (rx1017_rep, rx1017_pos, $I10, $P10) = rx1017_cur."!mark_fail"(0) + lt rx1017_pos, -1, rx1017_done + eq rx1017_pos, -1, rx1017_fail jump $I10 - rx1023_done: - rx1023_cur."!cursor_fail"() - rx1023_cur."!cursor_debug"("FAIL ", "prefix:sym<~>") - .return (rx1023_cur) + rx1017_done: + rx1017_cur."!cursor_fail"() + rx1017_cur."!cursor_debug"("FAIL ", "prefix:sym<-->") + .return (rx1017_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__prefix:sym<~>" :subid("256_1275511697.61926") :method -.annotate 'line', 433 - $P1025 = self."!PREFIX__!subrule"("O", "~") - new $P1026, "ResizablePMCArray" - push $P1026, $P1025 - .return ($P1026) +.sub "!PREFIX__prefix:sym<-->" :subid("255_1275600007.84296") :method +.annotate 'line', 445 + $P1019 = self."!PREFIX__!subrule"("O", "--") + new $P1020, "ResizablePMCArray" + push $P1020, $P1019 + .return ($P1020) .end .namespace ["NQP";"Grammar"] -.sub "prefix:sym<->" :subid("257_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1030_tgt - .local int rx1030_pos - .local int rx1030_off - .local int rx1030_eos - .local int rx1030_rep - .local pmc rx1030_cur - (rx1030_cur, rx1030_pos, rx1030_tgt) = self."!cursor_start"() - rx1030_cur."!cursor_debug"("START ", "prefix:sym<->") - .lex unicode:"$\x{a2}", rx1030_cur +.sub "postfix:sym<++>" :subid("256_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1024_tgt + .local int rx1024_pos + .local int rx1024_off + .local int rx1024_eos + .local int rx1024_rep + .local pmc rx1024_cur + (rx1024_cur, rx1024_pos, rx1024_tgt) = self."!cursor_start"() + rx1024_cur."!cursor_debug"("START ", "postfix:sym<++>") + .lex unicode:"$\x{a2}", rx1024_cur .local pmc match .lex "$/", match - length rx1030_eos, rx1030_tgt - gt rx1030_pos, rx1030_eos, rx1030_done - set rx1030_off, 0 - lt rx1030_pos, 2, rx1030_start - sub rx1030_off, rx1030_pos, 1 - substr rx1030_tgt, rx1030_tgt, rx1030_off - rx1030_start: + length rx1024_eos, rx1024_tgt + gt rx1024_pos, rx1024_eos, rx1024_done + set rx1024_off, 0 + lt rx1024_pos, 2, rx1024_start + sub rx1024_off, rx1024_pos, 1 + substr rx1024_tgt, rx1024_tgt, rx1024_off + rx1024_start: $I10 = self.'from'() - ne $I10, -1, rxscan1033_done - goto rxscan1033_scan - rxscan1033_loop: - ($P10) = rx1030_cur."from"() + ne $I10, -1, rxscan1028_done + goto rxscan1028_scan + rxscan1028_loop: + ($P10) = rx1024_cur."from"() inc $P10 - set rx1030_pos, $P10 - ge rx1030_pos, rx1030_eos, rxscan1033_done - rxscan1033_scan: - set_addr $I10, rxscan1033_loop - rx1030_cur."!mark_push"(0, rx1030_pos, $I10) - rxscan1033_done: -.annotate 'line', 488 + set rx1024_pos, $P10 + ge rx1024_pos, rx1024_eos, rxscan1028_done + rxscan1028_scan: + set_addr $I10, rxscan1028_loop + rx1024_cur."!mark_push"(0, rx1024_pos, $I10) + rxscan1028_done: +.annotate 'line', 493 # rx subcapture "sym" - set_addr $I10, rxcap_1034_fail - rx1030_cur."!mark_push"(0, rx1030_pos, $I10) - # rx literal "-" - add $I11, rx1030_pos, 1 - gt $I11, rx1030_eos, rx1030_fail - sub $I11, rx1030_pos, rx1030_off - substr $S10, rx1030_tgt, $I11, 1 - ne $S10, "-", rx1030_fail - add rx1030_pos, 1 - set_addr $I10, rxcap_1034_fail - ($I12, $I11) = rx1030_cur."!mark_peek"($I10) - rx1030_cur."!cursor_pos"($I11) - ($P10) = rx1030_cur."!cursor_start"() - $P10."!cursor_pass"(rx1030_pos, "") - rx1030_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1029_fail + rx1024_cur."!mark_push"(0, rx1024_pos, $I10) + # rx literal "++" + add $I11, rx1024_pos, 2 + gt $I11, rx1024_eos, rx1024_fail + sub $I11, rx1024_pos, rx1024_off + substr $S10, rx1024_tgt, $I11, 2 + ne $S10, "++", rx1024_fail + add rx1024_pos, 2 + set_addr $I10, rxcap_1029_fail + ($I12, $I11) = rx1024_cur."!mark_peek"($I10) + rx1024_cur."!cursor_pos"($I11) + ($P10) = rx1024_cur."!cursor_start"() + $P10."!cursor_pass"(rx1024_pos, "") + rx1024_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1034_done - rxcap_1034_fail: - goto rx1030_fail - rxcap_1034_done: - # rx enumcharlist negate=1 zerowidth - ge rx1030_pos, rx1030_eos, rx1030_fail - sub $I10, rx1030_pos, rx1030_off - substr $S10, rx1030_tgt, $I10, 1 - index $I11, ">", $S10 - ge $I11, 0, rx1030_fail - # rx subrule "number" subtype=zerowidth negate=1 - rx1030_cur."!cursor_pos"(rx1030_pos) - $P10 = rx1030_cur."number"() - if $P10, rx1030_fail + goto rxcap_1029_done + rxcap_1029_fail: + goto rx1024_fail + rxcap_1029_done: # rx subrule "O" subtype=capture negate= - rx1030_cur."!cursor_pos"(rx1030_pos) - $P10 = rx1030_cur."O"("%symbolic_unary, :pirop") - unless $P10, rx1030_fail - rx1030_cur."!mark_push"(0, -1, 0, $P10) + rx1024_cur."!cursor_pos"(rx1024_pos) + $P10 = rx1024_cur."O"("%autoincrement") + unless $P10, rx1024_fail + rx1024_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1030_pos = $P10."pos"() + rx1024_pos = $P10."pos"() # rx pass - rx1030_cur."!cursor_pass"(rx1030_pos, "prefix:sym<->") - rx1030_cur."!cursor_debug"("PASS ", "prefix:sym<->", " at pos=", rx1030_pos) - .return (rx1030_cur) - rx1030_fail: -.annotate 'line', 433 - (rx1030_rep, rx1030_pos, $I10, $P10) = rx1030_cur."!mark_fail"(0) - lt rx1030_pos, -1, rx1030_done - eq rx1030_pos, -1, rx1030_fail + rx1024_cur."!cursor_pass"(rx1024_pos, "postfix:sym<++>") + rx1024_cur."!cursor_debug"("PASS ", "postfix:sym<++>", " at pos=", rx1024_pos) + .return (rx1024_cur) + rx1024_fail: +.annotate 'line', 445 + (rx1024_rep, rx1024_pos, $I10, $P10) = rx1024_cur."!mark_fail"(0) + lt rx1024_pos, -1, rx1024_done + eq rx1024_pos, -1, rx1024_fail jump $I10 - rx1030_done: - rx1030_cur."!cursor_fail"() - rx1030_cur."!cursor_debug"("FAIL ", "prefix:sym<->") - .return (rx1030_cur) + rx1024_done: + rx1024_cur."!cursor_fail"() + rx1024_cur."!cursor_debug"("FAIL ", "postfix:sym<++>") + .return (rx1024_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__prefix:sym<->" :subid("258_1275511697.61926") :method -.annotate 'line', 433 - new $P1032, "ResizablePMCArray" - push $P1032, "-" - .return ($P1032) +.sub "!PREFIX__postfix:sym<++>" :subid("257_1275600007.84296") :method +.annotate 'line', 445 + $P1026 = self."!PREFIX__!subrule"("O", "++") + new $P1027, "ResizablePMCArray" + push $P1027, $P1026 + .return ($P1027) .end .namespace ["NQP";"Grammar"] -.sub "prefix:sym" :subid("259_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1036_tgt - .local int rx1036_pos - .local int rx1036_off - .local int rx1036_eos - .local int rx1036_rep - .local pmc rx1036_cur - (rx1036_cur, rx1036_pos, rx1036_tgt) = self."!cursor_start"() - rx1036_cur."!cursor_debug"("START ", "prefix:sym") - .lex unicode:"$\x{a2}", rx1036_cur +.sub "postfix:sym<-->" :subid("258_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1031_tgt + .local int rx1031_pos + .local int rx1031_off + .local int rx1031_eos + .local int rx1031_rep + .local pmc rx1031_cur + (rx1031_cur, rx1031_pos, rx1031_tgt) = self."!cursor_start"() + rx1031_cur."!cursor_debug"("START ", "postfix:sym<-->") + .lex unicode:"$\x{a2}", rx1031_cur .local pmc match .lex "$/", match - length rx1036_eos, rx1036_tgt - gt rx1036_pos, rx1036_eos, rx1036_done - set rx1036_off, 0 - lt rx1036_pos, 2, rx1036_start - sub rx1036_off, rx1036_pos, 1 - substr rx1036_tgt, rx1036_tgt, rx1036_off - rx1036_start: + length rx1031_eos, rx1031_tgt + gt rx1031_pos, rx1031_eos, rx1031_done + set rx1031_off, 0 + lt rx1031_pos, 2, rx1031_start + sub rx1031_off, rx1031_pos, 1 + substr rx1031_tgt, rx1031_tgt, rx1031_off + rx1031_start: $I10 = self.'from'() - ne $I10, -1, rxscan1040_done - goto rxscan1040_scan - rxscan1040_loop: - ($P10) = rx1036_cur."from"() + ne $I10, -1, rxscan1035_done + goto rxscan1035_scan + rxscan1035_loop: + ($P10) = rx1031_cur."from"() inc $P10 - set rx1036_pos, $P10 - ge rx1036_pos, rx1036_eos, rxscan1040_done - rxscan1040_scan: - set_addr $I10, rxscan1040_loop - rx1036_cur."!mark_push"(0, rx1036_pos, $I10) - rxscan1040_done: -.annotate 'line', 489 + set rx1031_pos, $P10 + ge rx1031_pos, rx1031_eos, rxscan1035_done + rxscan1035_scan: + set_addr $I10, rxscan1035_loop + rx1031_cur."!mark_push"(0, rx1031_pos, $I10) + rxscan1035_done: +.annotate 'line', 494 # rx subcapture "sym" - set_addr $I10, rxcap_1041_fail - rx1036_cur."!mark_push"(0, rx1036_pos, $I10) - # rx literal "?" - add $I11, rx1036_pos, 1 - gt $I11, rx1036_eos, rx1036_fail - sub $I11, rx1036_pos, rx1036_off - substr $S10, rx1036_tgt, $I11, 1 - ne $S10, "?", rx1036_fail - add rx1036_pos, 1 - set_addr $I10, rxcap_1041_fail - ($I12, $I11) = rx1036_cur."!mark_peek"($I10) - rx1036_cur."!cursor_pos"($I11) - ($P10) = rx1036_cur."!cursor_start"() - $P10."!cursor_pass"(rx1036_pos, "") - rx1036_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1036_fail + rx1031_cur."!mark_push"(0, rx1031_pos, $I10) + # rx literal "--" + add $I11, rx1031_pos, 2 + gt $I11, rx1031_eos, rx1031_fail + sub $I11, rx1031_pos, rx1031_off + substr $S10, rx1031_tgt, $I11, 2 + ne $S10, "--", rx1031_fail + add rx1031_pos, 2 + set_addr $I10, rxcap_1036_fail + ($I12, $I11) = rx1031_cur."!mark_peek"($I10) + rx1031_cur."!cursor_pos"($I11) + ($P10) = rx1031_cur."!cursor_start"() + $P10."!cursor_pass"(rx1031_pos, "") + rx1031_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1041_done - rxcap_1041_fail: - goto rx1036_fail - rxcap_1041_done: + goto rxcap_1036_done + rxcap_1036_fail: + goto rx1031_fail + rxcap_1036_done: # rx subrule "O" subtype=capture negate= - rx1036_cur."!cursor_pos"(rx1036_pos) - $P10 = rx1036_cur."O"("%symbolic_unary, :pirop") - unless $P10, rx1036_fail - rx1036_cur."!mark_push"(0, -1, 0, $P10) + rx1031_cur."!cursor_pos"(rx1031_pos) + $P10 = rx1031_cur."O"("%autoincrement") + unless $P10, rx1031_fail + rx1031_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1036_pos = $P10."pos"() + rx1031_pos = $P10."pos"() # rx pass - rx1036_cur."!cursor_pass"(rx1036_pos, "prefix:sym") - rx1036_cur."!cursor_debug"("PASS ", "prefix:sym", " at pos=", rx1036_pos) - .return (rx1036_cur) - rx1036_fail: -.annotate 'line', 433 - (rx1036_rep, rx1036_pos, $I10, $P10) = rx1036_cur."!mark_fail"(0) - lt rx1036_pos, -1, rx1036_done - eq rx1036_pos, -1, rx1036_fail + rx1031_cur."!cursor_pass"(rx1031_pos, "postfix:sym<-->") + rx1031_cur."!cursor_debug"("PASS ", "postfix:sym<-->", " at pos=", rx1031_pos) + .return (rx1031_cur) + rx1031_fail: +.annotate 'line', 445 + (rx1031_rep, rx1031_pos, $I10, $P10) = rx1031_cur."!mark_fail"(0) + lt rx1031_pos, -1, rx1031_done + eq rx1031_pos, -1, rx1031_fail jump $I10 - rx1036_done: - rx1036_cur."!cursor_fail"() - rx1036_cur."!cursor_debug"("FAIL ", "prefix:sym") - .return (rx1036_cur) + rx1031_done: + rx1031_cur."!cursor_fail"() + rx1031_cur."!cursor_debug"("FAIL ", "postfix:sym<-->") + .return (rx1031_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__prefix:sym" :subid("260_1275511697.61926") :method -.annotate 'line', 433 - $P1038 = self."!PREFIX__!subrule"("O", "?") - new $P1039, "ResizablePMCArray" - push $P1039, $P1038 - .return ($P1039) +.sub "!PREFIX__postfix:sym<-->" :subid("259_1275600007.84296") :method +.annotate 'line', 445 + $P1033 = self."!PREFIX__!subrule"("O", "--") + new $P1034, "ResizablePMCArray" + push $P1034, $P1033 + .return ($P1034) .end .namespace ["NQP";"Grammar"] -.sub "prefix:sym" :subid("261_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1043_tgt - .local int rx1043_pos - .local int rx1043_off - .local int rx1043_eos - .local int rx1043_rep - .local pmc rx1043_cur - (rx1043_cur, rx1043_pos, rx1043_tgt) = self."!cursor_start"() - rx1043_cur."!cursor_debug"("START ", "prefix:sym") - .lex unicode:"$\x{a2}", rx1043_cur +.sub "infix:sym<**>" :subid("260_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1038_tgt + .local int rx1038_pos + .local int rx1038_off + .local int rx1038_eos + .local int rx1038_rep + .local pmc rx1038_cur + (rx1038_cur, rx1038_pos, rx1038_tgt) = self."!cursor_start"() + rx1038_cur."!cursor_debug"("START ", "infix:sym<**>") + .lex unicode:"$\x{a2}", rx1038_cur .local pmc match .lex "$/", match - length rx1043_eos, rx1043_tgt - gt rx1043_pos, rx1043_eos, rx1043_done - set rx1043_off, 0 - lt rx1043_pos, 2, rx1043_start - sub rx1043_off, rx1043_pos, 1 - substr rx1043_tgt, rx1043_tgt, rx1043_off - rx1043_start: + length rx1038_eos, rx1038_tgt + gt rx1038_pos, rx1038_eos, rx1038_done + set rx1038_off, 0 + lt rx1038_pos, 2, rx1038_start + sub rx1038_off, rx1038_pos, 1 + substr rx1038_tgt, rx1038_tgt, rx1038_off + rx1038_start: $I10 = self.'from'() - ne $I10, -1, rxscan1047_done - goto rxscan1047_scan - rxscan1047_loop: - ($P10) = rx1043_cur."from"() + ne $I10, -1, rxscan1042_done + goto rxscan1042_scan + rxscan1042_loop: + ($P10) = rx1038_cur."from"() inc $P10 - set rx1043_pos, $P10 - ge rx1043_pos, rx1043_eos, rxscan1047_done - rxscan1047_scan: - set_addr $I10, rxscan1047_loop - rx1043_cur."!mark_push"(0, rx1043_pos, $I10) - rxscan1047_done: -.annotate 'line', 490 + set rx1038_pos, $P10 + ge rx1038_pos, rx1038_eos, rxscan1042_done + rxscan1042_scan: + set_addr $I10, rxscan1042_loop + rx1038_cur."!mark_push"(0, rx1038_pos, $I10) + rxscan1042_done: +.annotate 'line', 496 # rx subcapture "sym" - set_addr $I10, rxcap_1048_fail - rx1043_cur."!mark_push"(0, rx1043_pos, $I10) - # rx literal "!" - add $I11, rx1043_pos, 1 - gt $I11, rx1043_eos, rx1043_fail - sub $I11, rx1043_pos, rx1043_off - substr $S10, rx1043_tgt, $I11, 1 - ne $S10, "!", rx1043_fail - add rx1043_pos, 1 - set_addr $I10, rxcap_1048_fail - ($I12, $I11) = rx1043_cur."!mark_peek"($I10) - rx1043_cur."!cursor_pos"($I11) - ($P10) = rx1043_cur."!cursor_start"() - $P10."!cursor_pass"(rx1043_pos, "") - rx1043_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1043_fail + rx1038_cur."!mark_push"(0, rx1038_pos, $I10) + # rx literal "**" + add $I11, rx1038_pos, 2 + gt $I11, rx1038_eos, rx1038_fail + sub $I11, rx1038_pos, rx1038_off + substr $S10, rx1038_tgt, $I11, 2 + ne $S10, "**", rx1038_fail + add rx1038_pos, 2 + set_addr $I10, rxcap_1043_fail + ($I12, $I11) = rx1038_cur."!mark_peek"($I10) + rx1038_cur."!cursor_pos"($I11) + ($P10) = rx1038_cur."!cursor_start"() + $P10."!cursor_pass"(rx1038_pos, "") + rx1038_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1048_done - rxcap_1048_fail: - goto rx1043_fail - rxcap_1048_done: + goto rxcap_1043_done + rxcap_1043_fail: + goto rx1038_fail + rxcap_1043_done: # rx subrule "O" subtype=capture negate= - rx1043_cur."!cursor_pos"(rx1043_pos) - $P10 = rx1043_cur."O"("%symbolic_unary, :pirop") - unless $P10, rx1043_fail - rx1043_cur."!mark_push"(0, -1, 0, $P10) + rx1038_cur."!cursor_pos"(rx1038_pos) + $P10 = rx1038_cur."O"("%exponentiation, :pirop") + unless $P10, rx1038_fail + rx1038_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1043_pos = $P10."pos"() + rx1038_pos = $P10."pos"() # rx pass - rx1043_cur."!cursor_pass"(rx1043_pos, "prefix:sym") - rx1043_cur."!cursor_debug"("PASS ", "prefix:sym", " at pos=", rx1043_pos) - .return (rx1043_cur) - rx1043_fail: -.annotate 'line', 433 - (rx1043_rep, rx1043_pos, $I10, $P10) = rx1043_cur."!mark_fail"(0) - lt rx1043_pos, -1, rx1043_done - eq rx1043_pos, -1, rx1043_fail + rx1038_cur."!cursor_pass"(rx1038_pos, "infix:sym<**>") + rx1038_cur."!cursor_debug"("PASS ", "infix:sym<**>", " at pos=", rx1038_pos) + .return (rx1038_cur) + rx1038_fail: +.annotate 'line', 445 + (rx1038_rep, rx1038_pos, $I10, $P10) = rx1038_cur."!mark_fail"(0) + lt rx1038_pos, -1, rx1038_done + eq rx1038_pos, -1, rx1038_fail jump $I10 - rx1043_done: - rx1043_cur."!cursor_fail"() - rx1043_cur."!cursor_debug"("FAIL ", "prefix:sym") - .return (rx1043_cur) + rx1038_done: + rx1038_cur."!cursor_fail"() + rx1038_cur."!cursor_debug"("FAIL ", "infix:sym<**>") + .return (rx1038_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__prefix:sym" :subid("262_1275511697.61926") :method -.annotate 'line', 433 - $P1045 = self."!PREFIX__!subrule"("O", "!") - new $P1046, "ResizablePMCArray" - push $P1046, $P1045 - .return ($P1046) +.sub "!PREFIX__infix:sym<**>" :subid("261_1275600007.84296") :method +.annotate 'line', 445 + $P1040 = self."!PREFIX__!subrule"("O", "**") + new $P1041, "ResizablePMCArray" + push $P1041, $P1040 + .return ($P1041) .end .namespace ["NQP";"Grammar"] -.sub "prefix:sym<|>" :subid("263_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1050_tgt - .local int rx1050_pos - .local int rx1050_off - .local int rx1050_eos - .local int rx1050_rep - .local pmc rx1050_cur - (rx1050_cur, rx1050_pos, rx1050_tgt) = self."!cursor_start"() - rx1050_cur."!cursor_debug"("START ", "prefix:sym<|>") - .lex unicode:"$\x{a2}", rx1050_cur +.sub "prefix:sym<+>" :subid("262_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1045_tgt + .local int rx1045_pos + .local int rx1045_off + .local int rx1045_eos + .local int rx1045_rep + .local pmc rx1045_cur + (rx1045_cur, rx1045_pos, rx1045_tgt) = self."!cursor_start"() + rx1045_cur."!cursor_debug"("START ", "prefix:sym<+>") + .lex unicode:"$\x{a2}", rx1045_cur .local pmc match .lex "$/", match - length rx1050_eos, rx1050_tgt - gt rx1050_pos, rx1050_eos, rx1050_done - set rx1050_off, 0 - lt rx1050_pos, 2, rx1050_start - sub rx1050_off, rx1050_pos, 1 - substr rx1050_tgt, rx1050_tgt, rx1050_off - rx1050_start: + length rx1045_eos, rx1045_tgt + gt rx1045_pos, rx1045_eos, rx1045_done + set rx1045_off, 0 + lt rx1045_pos, 2, rx1045_start + sub rx1045_off, rx1045_pos, 1 + substr rx1045_tgt, rx1045_tgt, rx1045_off + rx1045_start: $I10 = self.'from'() - ne $I10, -1, rxscan1054_done - goto rxscan1054_scan - rxscan1054_loop: - ($P10) = rx1050_cur."from"() + ne $I10, -1, rxscan1049_done + goto rxscan1049_scan + rxscan1049_loop: + ($P10) = rx1045_cur."from"() inc $P10 - set rx1050_pos, $P10 - ge rx1050_pos, rx1050_eos, rxscan1054_done - rxscan1054_scan: - set_addr $I10, rxscan1054_loop - rx1050_cur."!mark_push"(0, rx1050_pos, $I10) - rxscan1054_done: -.annotate 'line', 491 + set rx1045_pos, $P10 + ge rx1045_pos, rx1045_eos, rxscan1049_done + rxscan1049_scan: + set_addr $I10, rxscan1049_loop + rx1045_cur."!mark_push"(0, rx1045_pos, $I10) + rxscan1049_done: +.annotate 'line', 498 # rx subcapture "sym" - set_addr $I10, rxcap_1055_fail - rx1050_cur."!mark_push"(0, rx1050_pos, $I10) - # rx literal "|" - add $I11, rx1050_pos, 1 - gt $I11, rx1050_eos, rx1050_fail - sub $I11, rx1050_pos, rx1050_off - substr $S10, rx1050_tgt, $I11, 1 - ne $S10, "|", rx1050_fail - add rx1050_pos, 1 - set_addr $I10, rxcap_1055_fail - ($I12, $I11) = rx1050_cur."!mark_peek"($I10) - rx1050_cur."!cursor_pos"($I11) - ($P10) = rx1050_cur."!cursor_start"() - $P10."!cursor_pass"(rx1050_pos, "") - rx1050_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1050_fail + rx1045_cur."!mark_push"(0, rx1045_pos, $I10) + # rx literal "+" + add $I11, rx1045_pos, 1 + gt $I11, rx1045_eos, rx1045_fail + sub $I11, rx1045_pos, rx1045_off + substr $S10, rx1045_tgt, $I11, 1 + ne $S10, "+", rx1045_fail + add rx1045_pos, 1 + set_addr $I10, rxcap_1050_fail + ($I12, $I11) = rx1045_cur."!mark_peek"($I10) + rx1045_cur."!cursor_pos"($I11) + ($P10) = rx1045_cur."!cursor_start"() + $P10."!cursor_pass"(rx1045_pos, "") + rx1045_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1055_done - rxcap_1055_fail: - goto rx1050_fail - rxcap_1055_done: + goto rxcap_1050_done + rxcap_1050_fail: + goto rx1045_fail + rxcap_1050_done: # rx subrule "O" subtype=capture negate= - rx1050_cur."!cursor_pos"(rx1050_pos) - $P10 = rx1050_cur."O"("%symbolic_unary") - unless $P10, rx1050_fail - rx1050_cur."!mark_push"(0, -1, 0, $P10) + rx1045_cur."!cursor_pos"(rx1045_pos) + $P10 = rx1045_cur."O"("%symbolic_unary, :pirop") + unless $P10, rx1045_fail + rx1045_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1050_pos = $P10."pos"() + rx1045_pos = $P10."pos"() # rx pass - rx1050_cur."!cursor_pass"(rx1050_pos, "prefix:sym<|>") - rx1050_cur."!cursor_debug"("PASS ", "prefix:sym<|>", " at pos=", rx1050_pos) - .return (rx1050_cur) - rx1050_fail: -.annotate 'line', 433 - (rx1050_rep, rx1050_pos, $I10, $P10) = rx1050_cur."!mark_fail"(0) - lt rx1050_pos, -1, rx1050_done - eq rx1050_pos, -1, rx1050_fail + rx1045_cur."!cursor_pass"(rx1045_pos, "prefix:sym<+>") + rx1045_cur."!cursor_debug"("PASS ", "prefix:sym<+>", " at pos=", rx1045_pos) + .return (rx1045_cur) + rx1045_fail: +.annotate 'line', 445 + (rx1045_rep, rx1045_pos, $I10, $P10) = rx1045_cur."!mark_fail"(0) + lt rx1045_pos, -1, rx1045_done + eq rx1045_pos, -1, rx1045_fail jump $I10 - rx1050_done: - rx1050_cur."!cursor_fail"() - rx1050_cur."!cursor_debug"("FAIL ", "prefix:sym<|>") - .return (rx1050_cur) + rx1045_done: + rx1045_cur."!cursor_fail"() + rx1045_cur."!cursor_debug"("FAIL ", "prefix:sym<+>") + .return (rx1045_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__prefix:sym<|>" :subid("264_1275511697.61926") :method -.annotate 'line', 433 - $P1052 = self."!PREFIX__!subrule"("O", "|") - new $P1053, "ResizablePMCArray" - push $P1053, $P1052 - .return ($P1053) +.sub "!PREFIX__prefix:sym<+>" :subid("263_1275600007.84296") :method +.annotate 'line', 445 + $P1047 = self."!PREFIX__!subrule"("O", "+") + new $P1048, "ResizablePMCArray" + push $P1048, $P1047 + .return ($P1048) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<*>" :subid("265_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1057_tgt - .local int rx1057_pos - .local int rx1057_off - .local int rx1057_eos - .local int rx1057_rep - .local pmc rx1057_cur - (rx1057_cur, rx1057_pos, rx1057_tgt) = self."!cursor_start"() - rx1057_cur."!cursor_debug"("START ", "infix:sym<*>") - .lex unicode:"$\x{a2}", rx1057_cur +.sub "prefix:sym<~>" :subid("264_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1052_tgt + .local int rx1052_pos + .local int rx1052_off + .local int rx1052_eos + .local int rx1052_rep + .local pmc rx1052_cur + (rx1052_cur, rx1052_pos, rx1052_tgt) = self."!cursor_start"() + rx1052_cur."!cursor_debug"("START ", "prefix:sym<~>") + .lex unicode:"$\x{a2}", rx1052_cur .local pmc match .lex "$/", match - length rx1057_eos, rx1057_tgt - gt rx1057_pos, rx1057_eos, rx1057_done - set rx1057_off, 0 - lt rx1057_pos, 2, rx1057_start - sub rx1057_off, rx1057_pos, 1 - substr rx1057_tgt, rx1057_tgt, rx1057_off - rx1057_start: + length rx1052_eos, rx1052_tgt + gt rx1052_pos, rx1052_eos, rx1052_done + set rx1052_off, 0 + lt rx1052_pos, 2, rx1052_start + sub rx1052_off, rx1052_pos, 1 + substr rx1052_tgt, rx1052_tgt, rx1052_off + rx1052_start: $I10 = self.'from'() - ne $I10, -1, rxscan1061_done - goto rxscan1061_scan - rxscan1061_loop: - ($P10) = rx1057_cur."from"() + ne $I10, -1, rxscan1056_done + goto rxscan1056_scan + rxscan1056_loop: + ($P10) = rx1052_cur."from"() inc $P10 - set rx1057_pos, $P10 - ge rx1057_pos, rx1057_eos, rxscan1061_done - rxscan1061_scan: - set_addr $I10, rxscan1061_loop - rx1057_cur."!mark_push"(0, rx1057_pos, $I10) - rxscan1061_done: -.annotate 'line', 493 + set rx1052_pos, $P10 + ge rx1052_pos, rx1052_eos, rxscan1056_done + rxscan1056_scan: + set_addr $I10, rxscan1056_loop + rx1052_cur."!mark_push"(0, rx1052_pos, $I10) + rxscan1056_done: +.annotate 'line', 499 # rx subcapture "sym" - set_addr $I10, rxcap_1062_fail - rx1057_cur."!mark_push"(0, rx1057_pos, $I10) - # rx literal "*" - add $I11, rx1057_pos, 1 - gt $I11, rx1057_eos, rx1057_fail - sub $I11, rx1057_pos, rx1057_off - substr $S10, rx1057_tgt, $I11, 1 - ne $S10, "*", rx1057_fail - add rx1057_pos, 1 - set_addr $I10, rxcap_1062_fail - ($I12, $I11) = rx1057_cur."!mark_peek"($I10) - rx1057_cur."!cursor_pos"($I11) - ($P10) = rx1057_cur."!cursor_start"() - $P10."!cursor_pass"(rx1057_pos, "") - rx1057_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1057_fail + rx1052_cur."!mark_push"(0, rx1052_pos, $I10) + # rx literal "~" + add $I11, rx1052_pos, 1 + gt $I11, rx1052_eos, rx1052_fail + sub $I11, rx1052_pos, rx1052_off + substr $S10, rx1052_tgt, $I11, 1 + ne $S10, "~", rx1052_fail + add rx1052_pos, 1 + set_addr $I10, rxcap_1057_fail + ($I12, $I11) = rx1052_cur."!mark_peek"($I10) + rx1052_cur."!cursor_pos"($I11) + ($P10) = rx1052_cur."!cursor_start"() + $P10."!cursor_pass"(rx1052_pos, "") + rx1052_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1062_done - rxcap_1062_fail: - goto rx1057_fail - rxcap_1062_done: + goto rxcap_1057_done + rxcap_1057_fail: + goto rx1052_fail + rxcap_1057_done: # rx subrule "O" subtype=capture negate= - rx1057_cur."!cursor_pos"(rx1057_pos) - $P10 = rx1057_cur."O"("%multiplicative, :pirop") - unless $P10, rx1057_fail - rx1057_cur."!mark_push"(0, -1, 0, $P10) + rx1052_cur."!cursor_pos"(rx1052_pos) + $P10 = rx1052_cur."O"("%symbolic_unary, :pirop") + unless $P10, rx1052_fail + rx1052_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1057_pos = $P10."pos"() + rx1052_pos = $P10."pos"() # rx pass - rx1057_cur."!cursor_pass"(rx1057_pos, "infix:sym<*>") - rx1057_cur."!cursor_debug"("PASS ", "infix:sym<*>", " at pos=", rx1057_pos) - .return (rx1057_cur) - rx1057_fail: -.annotate 'line', 433 - (rx1057_rep, rx1057_pos, $I10, $P10) = rx1057_cur."!mark_fail"(0) - lt rx1057_pos, -1, rx1057_done - eq rx1057_pos, -1, rx1057_fail + rx1052_cur."!cursor_pass"(rx1052_pos, "prefix:sym<~>") + rx1052_cur."!cursor_debug"("PASS ", "prefix:sym<~>", " at pos=", rx1052_pos) + .return (rx1052_cur) + rx1052_fail: +.annotate 'line', 445 + (rx1052_rep, rx1052_pos, $I10, $P10) = rx1052_cur."!mark_fail"(0) + lt rx1052_pos, -1, rx1052_done + eq rx1052_pos, -1, rx1052_fail jump $I10 - rx1057_done: - rx1057_cur."!cursor_fail"() - rx1057_cur."!cursor_debug"("FAIL ", "infix:sym<*>") - .return (rx1057_cur) + rx1052_done: + rx1052_cur."!cursor_fail"() + rx1052_cur."!cursor_debug"("FAIL ", "prefix:sym<~>") + .return (rx1052_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<*>" :subid("266_1275511697.61926") :method -.annotate 'line', 433 - $P1059 = self."!PREFIX__!subrule"("O", "*") - new $P1060, "ResizablePMCArray" - push $P1060, $P1059 - .return ($P1060) +.sub "!PREFIX__prefix:sym<~>" :subid("265_1275600007.84296") :method +.annotate 'line', 445 + $P1054 = self."!PREFIX__!subrule"("O", "~") + new $P1055, "ResizablePMCArray" + push $P1055, $P1054 + .return ($P1055) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym" :subid("267_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1064_tgt - .local int rx1064_pos - .local int rx1064_off - .local int rx1064_eos - .local int rx1064_rep - .local pmc rx1064_cur - (rx1064_cur, rx1064_pos, rx1064_tgt) = self."!cursor_start"() - rx1064_cur."!cursor_debug"("START ", "infix:sym") - .lex unicode:"$\x{a2}", rx1064_cur +.sub "prefix:sym<->" :subid("266_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1059_tgt + .local int rx1059_pos + .local int rx1059_off + .local int rx1059_eos + .local int rx1059_rep + .local pmc rx1059_cur + (rx1059_cur, rx1059_pos, rx1059_tgt) = self."!cursor_start"() + rx1059_cur."!cursor_debug"("START ", "prefix:sym<->") + .lex unicode:"$\x{a2}", rx1059_cur .local pmc match .lex "$/", match - length rx1064_eos, rx1064_tgt - gt rx1064_pos, rx1064_eos, rx1064_done - set rx1064_off, 0 - lt rx1064_pos, 2, rx1064_start - sub rx1064_off, rx1064_pos, 1 - substr rx1064_tgt, rx1064_tgt, rx1064_off - rx1064_start: + length rx1059_eos, rx1059_tgt + gt rx1059_pos, rx1059_eos, rx1059_done + set rx1059_off, 0 + lt rx1059_pos, 2, rx1059_start + sub rx1059_off, rx1059_pos, 1 + substr rx1059_tgt, rx1059_tgt, rx1059_off + rx1059_start: $I10 = self.'from'() - ne $I10, -1, rxscan1068_done - goto rxscan1068_scan - rxscan1068_loop: - ($P10) = rx1064_cur."from"() + ne $I10, -1, rxscan1062_done + goto rxscan1062_scan + rxscan1062_loop: + ($P10) = rx1059_cur."from"() inc $P10 - set rx1064_pos, $P10 - ge rx1064_pos, rx1064_eos, rxscan1068_done - rxscan1068_scan: - set_addr $I10, rxscan1068_loop - rx1064_cur."!mark_push"(0, rx1064_pos, $I10) - rxscan1068_done: -.annotate 'line', 494 + set rx1059_pos, $P10 + ge rx1059_pos, rx1059_eos, rxscan1062_done + rxscan1062_scan: + set_addr $I10, rxscan1062_loop + rx1059_cur."!mark_push"(0, rx1059_pos, $I10) + rxscan1062_done: +.annotate 'line', 500 # rx subcapture "sym" - set_addr $I10, rxcap_1069_fail - rx1064_cur."!mark_push"(0, rx1064_pos, $I10) - # rx literal "/" - add $I11, rx1064_pos, 1 - gt $I11, rx1064_eos, rx1064_fail - sub $I11, rx1064_pos, rx1064_off - substr $S10, rx1064_tgt, $I11, 1 - ne $S10, "/", rx1064_fail - add rx1064_pos, 1 - set_addr $I10, rxcap_1069_fail - ($I12, $I11) = rx1064_cur."!mark_peek"($I10) - rx1064_cur."!cursor_pos"($I11) - ($P10) = rx1064_cur."!cursor_start"() - $P10."!cursor_pass"(rx1064_pos, "") - rx1064_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1063_fail + rx1059_cur."!mark_push"(0, rx1059_pos, $I10) + # rx literal "-" + add $I11, rx1059_pos, 1 + gt $I11, rx1059_eos, rx1059_fail + sub $I11, rx1059_pos, rx1059_off + substr $S10, rx1059_tgt, $I11, 1 + ne $S10, "-", rx1059_fail + add rx1059_pos, 1 + set_addr $I10, rxcap_1063_fail + ($I12, $I11) = rx1059_cur."!mark_peek"($I10) + rx1059_cur."!cursor_pos"($I11) + ($P10) = rx1059_cur."!cursor_start"() + $P10."!cursor_pass"(rx1059_pos, "") + rx1059_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1069_done - rxcap_1069_fail: - goto rx1064_fail - rxcap_1069_done: + goto rxcap_1063_done + rxcap_1063_fail: + goto rx1059_fail + rxcap_1063_done: + # rx enumcharlist negate=1 zerowidth + ge rx1059_pos, rx1059_eos, rx1059_fail + sub $I10, rx1059_pos, rx1059_off + substr $S10, rx1059_tgt, $I10, 1 + index $I11, ">", $S10 + ge $I11, 0, rx1059_fail + # rx subrule "number" subtype=zerowidth negate=1 + rx1059_cur."!cursor_pos"(rx1059_pos) + $P10 = rx1059_cur."number"() + if $P10, rx1059_fail # rx subrule "O" subtype=capture negate= - rx1064_cur."!cursor_pos"(rx1064_pos) - $P10 = rx1064_cur."O"("%multiplicative, :pirop
") - unless $P10, rx1064_fail - rx1064_cur."!mark_push"(0, -1, 0, $P10) + rx1059_cur."!cursor_pos"(rx1059_pos) + $P10 = rx1059_cur."O"("%symbolic_unary, :pirop") + unless $P10, rx1059_fail + rx1059_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1064_pos = $P10."pos"() + rx1059_pos = $P10."pos"() # rx pass - rx1064_cur."!cursor_pass"(rx1064_pos, "infix:sym") - rx1064_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1064_pos) - .return (rx1064_cur) - rx1064_fail: -.annotate 'line', 433 - (rx1064_rep, rx1064_pos, $I10, $P10) = rx1064_cur."!mark_fail"(0) - lt rx1064_pos, -1, rx1064_done - eq rx1064_pos, -1, rx1064_fail + rx1059_cur."!cursor_pass"(rx1059_pos, "prefix:sym<->") + rx1059_cur."!cursor_debug"("PASS ", "prefix:sym<->", " at pos=", rx1059_pos) + .return (rx1059_cur) + rx1059_fail: +.annotate 'line', 445 + (rx1059_rep, rx1059_pos, $I10, $P10) = rx1059_cur."!mark_fail"(0) + lt rx1059_pos, -1, rx1059_done + eq rx1059_pos, -1, rx1059_fail jump $I10 - rx1064_done: - rx1064_cur."!cursor_fail"() - rx1064_cur."!cursor_debug"("FAIL ", "infix:sym") - .return (rx1064_cur) + rx1059_done: + rx1059_cur."!cursor_fail"() + rx1059_cur."!cursor_debug"("FAIL ", "prefix:sym<->") + .return (rx1059_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym" :subid("268_1275511697.61926") :method -.annotate 'line', 433 - $P1066 = self."!PREFIX__!subrule"("O", "/") - new $P1067, "ResizablePMCArray" - push $P1067, $P1066 - .return ($P1067) +.sub "!PREFIX__prefix:sym<->" :subid("267_1275600007.84296") :method +.annotate 'line', 445 + new $P1061, "ResizablePMCArray" + push $P1061, "-" + .return ($P1061) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<%>" :subid("269_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1071_tgt - .local int rx1071_pos - .local int rx1071_off - .local int rx1071_eos - .local int rx1071_rep - .local pmc rx1071_cur - (rx1071_cur, rx1071_pos, rx1071_tgt) = self."!cursor_start"() - rx1071_cur."!cursor_debug"("START ", "infix:sym<%>") - .lex unicode:"$\x{a2}", rx1071_cur +.sub "prefix:sym" :subid("268_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1065_tgt + .local int rx1065_pos + .local int rx1065_off + .local int rx1065_eos + .local int rx1065_rep + .local pmc rx1065_cur + (rx1065_cur, rx1065_pos, rx1065_tgt) = self."!cursor_start"() + rx1065_cur."!cursor_debug"("START ", "prefix:sym") + .lex unicode:"$\x{a2}", rx1065_cur .local pmc match .lex "$/", match - length rx1071_eos, rx1071_tgt - gt rx1071_pos, rx1071_eos, rx1071_done - set rx1071_off, 0 - lt rx1071_pos, 2, rx1071_start - sub rx1071_off, rx1071_pos, 1 - substr rx1071_tgt, rx1071_tgt, rx1071_off - rx1071_start: + length rx1065_eos, rx1065_tgt + gt rx1065_pos, rx1065_eos, rx1065_done + set rx1065_off, 0 + lt rx1065_pos, 2, rx1065_start + sub rx1065_off, rx1065_pos, 1 + substr rx1065_tgt, rx1065_tgt, rx1065_off + rx1065_start: $I10 = self.'from'() - ne $I10, -1, rxscan1075_done - goto rxscan1075_scan - rxscan1075_loop: - ($P10) = rx1071_cur."from"() + ne $I10, -1, rxscan1069_done + goto rxscan1069_scan + rxscan1069_loop: + ($P10) = rx1065_cur."from"() inc $P10 - set rx1071_pos, $P10 - ge rx1071_pos, rx1071_eos, rxscan1075_done - rxscan1075_scan: - set_addr $I10, rxscan1075_loop - rx1071_cur."!mark_push"(0, rx1071_pos, $I10) - rxscan1075_done: -.annotate 'line', 495 + set rx1065_pos, $P10 + ge rx1065_pos, rx1065_eos, rxscan1069_done + rxscan1069_scan: + set_addr $I10, rxscan1069_loop + rx1065_cur."!mark_push"(0, rx1065_pos, $I10) + rxscan1069_done: +.annotate 'line', 501 # rx subcapture "sym" - set_addr $I10, rxcap_1076_fail - rx1071_cur."!mark_push"(0, rx1071_pos, $I10) - # rx literal "%" - add $I11, rx1071_pos, 1 - gt $I11, rx1071_eos, rx1071_fail - sub $I11, rx1071_pos, rx1071_off - substr $S10, rx1071_tgt, $I11, 1 - ne $S10, "%", rx1071_fail - add rx1071_pos, 1 - set_addr $I10, rxcap_1076_fail - ($I12, $I11) = rx1071_cur."!mark_peek"($I10) - rx1071_cur."!cursor_pos"($I11) - ($P10) = rx1071_cur."!cursor_start"() - $P10."!cursor_pass"(rx1071_pos, "") - rx1071_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1070_fail + rx1065_cur."!mark_push"(0, rx1065_pos, $I10) + # rx literal "?" + add $I11, rx1065_pos, 1 + gt $I11, rx1065_eos, rx1065_fail + sub $I11, rx1065_pos, rx1065_off + substr $S10, rx1065_tgt, $I11, 1 + ne $S10, "?", rx1065_fail + add rx1065_pos, 1 + set_addr $I10, rxcap_1070_fail + ($I12, $I11) = rx1065_cur."!mark_peek"($I10) + rx1065_cur."!cursor_pos"($I11) + ($P10) = rx1065_cur."!cursor_start"() + $P10."!cursor_pass"(rx1065_pos, "") + rx1065_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1076_done - rxcap_1076_fail: - goto rx1071_fail - rxcap_1076_done: + goto rxcap_1070_done + rxcap_1070_fail: + goto rx1065_fail + rxcap_1070_done: # rx subrule "O" subtype=capture negate= - rx1071_cur."!cursor_pos"(rx1071_pos) - $P10 = rx1071_cur."O"("%multiplicative, :pirop") - unless $P10, rx1071_fail - rx1071_cur."!mark_push"(0, -1, 0, $P10) + rx1065_cur."!cursor_pos"(rx1065_pos) + $P10 = rx1065_cur."O"("%symbolic_unary, :pirop") + unless $P10, rx1065_fail + rx1065_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1071_pos = $P10."pos"() + rx1065_pos = $P10."pos"() # rx pass - rx1071_cur."!cursor_pass"(rx1071_pos, "infix:sym<%>") - rx1071_cur."!cursor_debug"("PASS ", "infix:sym<%>", " at pos=", rx1071_pos) - .return (rx1071_cur) - rx1071_fail: -.annotate 'line', 433 - (rx1071_rep, rx1071_pos, $I10, $P10) = rx1071_cur."!mark_fail"(0) - lt rx1071_pos, -1, rx1071_done - eq rx1071_pos, -1, rx1071_fail + rx1065_cur."!cursor_pass"(rx1065_pos, "prefix:sym") + rx1065_cur."!cursor_debug"("PASS ", "prefix:sym", " at pos=", rx1065_pos) + .return (rx1065_cur) + rx1065_fail: +.annotate 'line', 445 + (rx1065_rep, rx1065_pos, $I10, $P10) = rx1065_cur."!mark_fail"(0) + lt rx1065_pos, -1, rx1065_done + eq rx1065_pos, -1, rx1065_fail jump $I10 - rx1071_done: - rx1071_cur."!cursor_fail"() - rx1071_cur."!cursor_debug"("FAIL ", "infix:sym<%>") - .return (rx1071_cur) + rx1065_done: + rx1065_cur."!cursor_fail"() + rx1065_cur."!cursor_debug"("FAIL ", "prefix:sym") + .return (rx1065_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<%>" :subid("270_1275511697.61926") :method -.annotate 'line', 433 - $P1073 = self."!PREFIX__!subrule"("O", "%") - new $P1074, "ResizablePMCArray" - push $P1074, $P1073 - .return ($P1074) +.sub "!PREFIX__prefix:sym" :subid("269_1275600007.84296") :method +.annotate 'line', 445 + $P1067 = self."!PREFIX__!subrule"("O", "?") + new $P1068, "ResizablePMCArray" + push $P1068, $P1067 + .return ($P1068) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<+>" :subid("271_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1078_tgt - .local int rx1078_pos - .local int rx1078_off - .local int rx1078_eos - .local int rx1078_rep - .local pmc rx1078_cur - (rx1078_cur, rx1078_pos, rx1078_tgt) = self."!cursor_start"() - rx1078_cur."!cursor_debug"("START ", "infix:sym<+>") - .lex unicode:"$\x{a2}", rx1078_cur +.sub "prefix:sym" :subid("270_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1072_tgt + .local int rx1072_pos + .local int rx1072_off + .local int rx1072_eos + .local int rx1072_rep + .local pmc rx1072_cur + (rx1072_cur, rx1072_pos, rx1072_tgt) = self."!cursor_start"() + rx1072_cur."!cursor_debug"("START ", "prefix:sym") + .lex unicode:"$\x{a2}", rx1072_cur .local pmc match .lex "$/", match - length rx1078_eos, rx1078_tgt - gt rx1078_pos, rx1078_eos, rx1078_done - set rx1078_off, 0 - lt rx1078_pos, 2, rx1078_start - sub rx1078_off, rx1078_pos, 1 - substr rx1078_tgt, rx1078_tgt, rx1078_off - rx1078_start: + length rx1072_eos, rx1072_tgt + gt rx1072_pos, rx1072_eos, rx1072_done + set rx1072_off, 0 + lt rx1072_pos, 2, rx1072_start + sub rx1072_off, rx1072_pos, 1 + substr rx1072_tgt, rx1072_tgt, rx1072_off + rx1072_start: $I10 = self.'from'() - ne $I10, -1, rxscan1082_done - goto rxscan1082_scan - rxscan1082_loop: - ($P10) = rx1078_cur."from"() + ne $I10, -1, rxscan1076_done + goto rxscan1076_scan + rxscan1076_loop: + ($P10) = rx1072_cur."from"() inc $P10 - set rx1078_pos, $P10 - ge rx1078_pos, rx1078_eos, rxscan1082_done - rxscan1082_scan: - set_addr $I10, rxscan1082_loop - rx1078_cur."!mark_push"(0, rx1078_pos, $I10) - rxscan1082_done: -.annotate 'line', 497 + set rx1072_pos, $P10 + ge rx1072_pos, rx1072_eos, rxscan1076_done + rxscan1076_scan: + set_addr $I10, rxscan1076_loop + rx1072_cur."!mark_push"(0, rx1072_pos, $I10) + rxscan1076_done: +.annotate 'line', 502 # rx subcapture "sym" - set_addr $I10, rxcap_1083_fail - rx1078_cur."!mark_push"(0, rx1078_pos, $I10) - # rx literal "+" - add $I11, rx1078_pos, 1 - gt $I11, rx1078_eos, rx1078_fail - sub $I11, rx1078_pos, rx1078_off - substr $S10, rx1078_tgt, $I11, 1 - ne $S10, "+", rx1078_fail - add rx1078_pos, 1 - set_addr $I10, rxcap_1083_fail - ($I12, $I11) = rx1078_cur."!mark_peek"($I10) - rx1078_cur."!cursor_pos"($I11) - ($P10) = rx1078_cur."!cursor_start"() - $P10."!cursor_pass"(rx1078_pos, "") - rx1078_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1077_fail + rx1072_cur."!mark_push"(0, rx1072_pos, $I10) + # rx literal "!" + add $I11, rx1072_pos, 1 + gt $I11, rx1072_eos, rx1072_fail + sub $I11, rx1072_pos, rx1072_off + substr $S10, rx1072_tgt, $I11, 1 + ne $S10, "!", rx1072_fail + add rx1072_pos, 1 + set_addr $I10, rxcap_1077_fail + ($I12, $I11) = rx1072_cur."!mark_peek"($I10) + rx1072_cur."!cursor_pos"($I11) + ($P10) = rx1072_cur."!cursor_start"() + $P10."!cursor_pass"(rx1072_pos, "") + rx1072_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1083_done - rxcap_1083_fail: - goto rx1078_fail - rxcap_1083_done: + goto rxcap_1077_done + rxcap_1077_fail: + goto rx1072_fail + rxcap_1077_done: # rx subrule "O" subtype=capture negate= - rx1078_cur."!cursor_pos"(rx1078_pos) - $P10 = rx1078_cur."O"("%additive, :pirop") - unless $P10, rx1078_fail - rx1078_cur."!mark_push"(0, -1, 0, $P10) + rx1072_cur."!cursor_pos"(rx1072_pos) + $P10 = rx1072_cur."O"("%symbolic_unary, :pirop") + unless $P10, rx1072_fail + rx1072_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1078_pos = $P10."pos"() + rx1072_pos = $P10."pos"() # rx pass - rx1078_cur."!cursor_pass"(rx1078_pos, "infix:sym<+>") - rx1078_cur."!cursor_debug"("PASS ", "infix:sym<+>", " at pos=", rx1078_pos) - .return (rx1078_cur) - rx1078_fail: -.annotate 'line', 433 - (rx1078_rep, rx1078_pos, $I10, $P10) = rx1078_cur."!mark_fail"(0) - lt rx1078_pos, -1, rx1078_done - eq rx1078_pos, -1, rx1078_fail + rx1072_cur."!cursor_pass"(rx1072_pos, "prefix:sym") + rx1072_cur."!cursor_debug"("PASS ", "prefix:sym", " at pos=", rx1072_pos) + .return (rx1072_cur) + rx1072_fail: +.annotate 'line', 445 + (rx1072_rep, rx1072_pos, $I10, $P10) = rx1072_cur."!mark_fail"(0) + lt rx1072_pos, -1, rx1072_done + eq rx1072_pos, -1, rx1072_fail jump $I10 - rx1078_done: - rx1078_cur."!cursor_fail"() - rx1078_cur."!cursor_debug"("FAIL ", "infix:sym<+>") - .return (rx1078_cur) + rx1072_done: + rx1072_cur."!cursor_fail"() + rx1072_cur."!cursor_debug"("FAIL ", "prefix:sym") + .return (rx1072_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<+>" :subid("272_1275511697.61926") :method -.annotate 'line', 433 - $P1080 = self."!PREFIX__!subrule"("O", "+") - new $P1081, "ResizablePMCArray" - push $P1081, $P1080 - .return ($P1081) +.sub "!PREFIX__prefix:sym" :subid("271_1275600007.84296") :method +.annotate 'line', 445 + $P1074 = self."!PREFIX__!subrule"("O", "!") + new $P1075, "ResizablePMCArray" + push $P1075, $P1074 + .return ($P1075) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<->" :subid("273_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1085_tgt - .local int rx1085_pos - .local int rx1085_off - .local int rx1085_eos - .local int rx1085_rep - .local pmc rx1085_cur - (rx1085_cur, rx1085_pos, rx1085_tgt) = self."!cursor_start"() - rx1085_cur."!cursor_debug"("START ", "infix:sym<->") - .lex unicode:"$\x{a2}", rx1085_cur +.sub "prefix:sym<|>" :subid("272_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1079_tgt + .local int rx1079_pos + .local int rx1079_off + .local int rx1079_eos + .local int rx1079_rep + .local pmc rx1079_cur + (rx1079_cur, rx1079_pos, rx1079_tgt) = self."!cursor_start"() + rx1079_cur."!cursor_debug"("START ", "prefix:sym<|>") + .lex unicode:"$\x{a2}", rx1079_cur .local pmc match .lex "$/", match - length rx1085_eos, rx1085_tgt - gt rx1085_pos, rx1085_eos, rx1085_done - set rx1085_off, 0 - lt rx1085_pos, 2, rx1085_start - sub rx1085_off, rx1085_pos, 1 - substr rx1085_tgt, rx1085_tgt, rx1085_off - rx1085_start: + length rx1079_eos, rx1079_tgt + gt rx1079_pos, rx1079_eos, rx1079_done + set rx1079_off, 0 + lt rx1079_pos, 2, rx1079_start + sub rx1079_off, rx1079_pos, 1 + substr rx1079_tgt, rx1079_tgt, rx1079_off + rx1079_start: $I10 = self.'from'() - ne $I10, -1, rxscan1089_done - goto rxscan1089_scan - rxscan1089_loop: - ($P10) = rx1085_cur."from"() + ne $I10, -1, rxscan1083_done + goto rxscan1083_scan + rxscan1083_loop: + ($P10) = rx1079_cur."from"() inc $P10 - set rx1085_pos, $P10 - ge rx1085_pos, rx1085_eos, rxscan1089_done - rxscan1089_scan: - set_addr $I10, rxscan1089_loop - rx1085_cur."!mark_push"(0, rx1085_pos, $I10) - rxscan1089_done: -.annotate 'line', 498 + set rx1079_pos, $P10 + ge rx1079_pos, rx1079_eos, rxscan1083_done + rxscan1083_scan: + set_addr $I10, rxscan1083_loop + rx1079_cur."!mark_push"(0, rx1079_pos, $I10) + rxscan1083_done: +.annotate 'line', 503 # rx subcapture "sym" - set_addr $I10, rxcap_1090_fail - rx1085_cur."!mark_push"(0, rx1085_pos, $I10) - # rx literal "-" - add $I11, rx1085_pos, 1 - gt $I11, rx1085_eos, rx1085_fail - sub $I11, rx1085_pos, rx1085_off - substr $S10, rx1085_tgt, $I11, 1 - ne $S10, "-", rx1085_fail - add rx1085_pos, 1 - set_addr $I10, rxcap_1090_fail - ($I12, $I11) = rx1085_cur."!mark_peek"($I10) - rx1085_cur."!cursor_pos"($I11) - ($P10) = rx1085_cur."!cursor_start"() - $P10."!cursor_pass"(rx1085_pos, "") - rx1085_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1084_fail + rx1079_cur."!mark_push"(0, rx1079_pos, $I10) + # rx literal "|" + add $I11, rx1079_pos, 1 + gt $I11, rx1079_eos, rx1079_fail + sub $I11, rx1079_pos, rx1079_off + substr $S10, rx1079_tgt, $I11, 1 + ne $S10, "|", rx1079_fail + add rx1079_pos, 1 + set_addr $I10, rxcap_1084_fail + ($I12, $I11) = rx1079_cur."!mark_peek"($I10) + rx1079_cur."!cursor_pos"($I11) + ($P10) = rx1079_cur."!cursor_start"() + $P10."!cursor_pass"(rx1079_pos, "") + rx1079_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1090_done - rxcap_1090_fail: - goto rx1085_fail - rxcap_1090_done: + goto rxcap_1084_done + rxcap_1084_fail: + goto rx1079_fail + rxcap_1084_done: # rx subrule "O" subtype=capture negate= - rx1085_cur."!cursor_pos"(rx1085_pos) - $P10 = rx1085_cur."O"("%additive, :pirop") - unless $P10, rx1085_fail - rx1085_cur."!mark_push"(0, -1, 0, $P10) + rx1079_cur."!cursor_pos"(rx1079_pos) + $P10 = rx1079_cur."O"("%symbolic_unary") + unless $P10, rx1079_fail + rx1079_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1085_pos = $P10."pos"() + rx1079_pos = $P10."pos"() # rx pass - rx1085_cur."!cursor_pass"(rx1085_pos, "infix:sym<->") - rx1085_cur."!cursor_debug"("PASS ", "infix:sym<->", " at pos=", rx1085_pos) - .return (rx1085_cur) - rx1085_fail: -.annotate 'line', 433 - (rx1085_rep, rx1085_pos, $I10, $P10) = rx1085_cur."!mark_fail"(0) - lt rx1085_pos, -1, rx1085_done - eq rx1085_pos, -1, rx1085_fail + rx1079_cur."!cursor_pass"(rx1079_pos, "prefix:sym<|>") + rx1079_cur."!cursor_debug"("PASS ", "prefix:sym<|>", " at pos=", rx1079_pos) + .return (rx1079_cur) + rx1079_fail: +.annotate 'line', 445 + (rx1079_rep, rx1079_pos, $I10, $P10) = rx1079_cur."!mark_fail"(0) + lt rx1079_pos, -1, rx1079_done + eq rx1079_pos, -1, rx1079_fail jump $I10 - rx1085_done: - rx1085_cur."!cursor_fail"() - rx1085_cur."!cursor_debug"("FAIL ", "infix:sym<->") - .return (rx1085_cur) + rx1079_done: + rx1079_cur."!cursor_fail"() + rx1079_cur."!cursor_debug"("FAIL ", "prefix:sym<|>") + .return (rx1079_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<->" :subid("274_1275511697.61926") :method -.annotate 'line', 433 - $P1087 = self."!PREFIX__!subrule"("O", "-") - new $P1088, "ResizablePMCArray" - push $P1088, $P1087 - .return ($P1088) +.sub "!PREFIX__prefix:sym<|>" :subid("273_1275600007.84296") :method +.annotate 'line', 445 + $P1081 = self."!PREFIX__!subrule"("O", "|") + new $P1082, "ResizablePMCArray" + push $P1082, $P1081 + .return ($P1082) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<~>" :subid("275_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1092_tgt - .local int rx1092_pos - .local int rx1092_off - .local int rx1092_eos - .local int rx1092_rep - .local pmc rx1092_cur - (rx1092_cur, rx1092_pos, rx1092_tgt) = self."!cursor_start"() - rx1092_cur."!cursor_debug"("START ", "infix:sym<~>") - .lex unicode:"$\x{a2}", rx1092_cur +.sub "infix:sym<*>" :subid("274_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1086_tgt + .local int rx1086_pos + .local int rx1086_off + .local int rx1086_eos + .local int rx1086_rep + .local pmc rx1086_cur + (rx1086_cur, rx1086_pos, rx1086_tgt) = self."!cursor_start"() + rx1086_cur."!cursor_debug"("START ", "infix:sym<*>") + .lex unicode:"$\x{a2}", rx1086_cur .local pmc match .lex "$/", match - length rx1092_eos, rx1092_tgt - gt rx1092_pos, rx1092_eos, rx1092_done - set rx1092_off, 0 - lt rx1092_pos, 2, rx1092_start - sub rx1092_off, rx1092_pos, 1 - substr rx1092_tgt, rx1092_tgt, rx1092_off - rx1092_start: + length rx1086_eos, rx1086_tgt + gt rx1086_pos, rx1086_eos, rx1086_done + set rx1086_off, 0 + lt rx1086_pos, 2, rx1086_start + sub rx1086_off, rx1086_pos, 1 + substr rx1086_tgt, rx1086_tgt, rx1086_off + rx1086_start: $I10 = self.'from'() - ne $I10, -1, rxscan1096_done - goto rxscan1096_scan - rxscan1096_loop: - ($P10) = rx1092_cur."from"() + ne $I10, -1, rxscan1090_done + goto rxscan1090_scan + rxscan1090_loop: + ($P10) = rx1086_cur."from"() inc $P10 - set rx1092_pos, $P10 - ge rx1092_pos, rx1092_eos, rxscan1096_done - rxscan1096_scan: - set_addr $I10, rxscan1096_loop - rx1092_cur."!mark_push"(0, rx1092_pos, $I10) - rxscan1096_done: -.annotate 'line', 500 + set rx1086_pos, $P10 + ge rx1086_pos, rx1086_eos, rxscan1090_done + rxscan1090_scan: + set_addr $I10, rxscan1090_loop + rx1086_cur."!mark_push"(0, rx1086_pos, $I10) + rxscan1090_done: +.annotate 'line', 505 # rx subcapture "sym" - set_addr $I10, rxcap_1097_fail - rx1092_cur."!mark_push"(0, rx1092_pos, $I10) - # rx literal "~" - add $I11, rx1092_pos, 1 - gt $I11, rx1092_eos, rx1092_fail - sub $I11, rx1092_pos, rx1092_off - substr $S10, rx1092_tgt, $I11, 1 - ne $S10, "~", rx1092_fail - add rx1092_pos, 1 - set_addr $I10, rxcap_1097_fail - ($I12, $I11) = rx1092_cur."!mark_peek"($I10) - rx1092_cur."!cursor_pos"($I11) - ($P10) = rx1092_cur."!cursor_start"() - $P10."!cursor_pass"(rx1092_pos, "") - rx1092_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1091_fail + rx1086_cur."!mark_push"(0, rx1086_pos, $I10) + # rx literal "*" + add $I11, rx1086_pos, 1 + gt $I11, rx1086_eos, rx1086_fail + sub $I11, rx1086_pos, rx1086_off + substr $S10, rx1086_tgt, $I11, 1 + ne $S10, "*", rx1086_fail + add rx1086_pos, 1 + set_addr $I10, rxcap_1091_fail + ($I12, $I11) = rx1086_cur."!mark_peek"($I10) + rx1086_cur."!cursor_pos"($I11) + ($P10) = rx1086_cur."!cursor_start"() + $P10."!cursor_pass"(rx1086_pos, "") + rx1086_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1097_done - rxcap_1097_fail: - goto rx1092_fail - rxcap_1097_done: + goto rxcap_1091_done + rxcap_1091_fail: + goto rx1086_fail + rxcap_1091_done: # rx subrule "O" subtype=capture negate= - rx1092_cur."!cursor_pos"(rx1092_pos) - $P10 = rx1092_cur."O"("%concatenation , :pirop") - unless $P10, rx1092_fail - rx1092_cur."!mark_push"(0, -1, 0, $P10) + rx1086_cur."!cursor_pos"(rx1086_pos) + $P10 = rx1086_cur."O"("%multiplicative, :pirop") + unless $P10, rx1086_fail + rx1086_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1092_pos = $P10."pos"() + rx1086_pos = $P10."pos"() # rx pass - rx1092_cur."!cursor_pass"(rx1092_pos, "infix:sym<~>") - rx1092_cur."!cursor_debug"("PASS ", "infix:sym<~>", " at pos=", rx1092_pos) - .return (rx1092_cur) - rx1092_fail: -.annotate 'line', 433 - (rx1092_rep, rx1092_pos, $I10, $P10) = rx1092_cur."!mark_fail"(0) - lt rx1092_pos, -1, rx1092_done - eq rx1092_pos, -1, rx1092_fail + rx1086_cur."!cursor_pass"(rx1086_pos, "infix:sym<*>") + rx1086_cur."!cursor_debug"("PASS ", "infix:sym<*>", " at pos=", rx1086_pos) + .return (rx1086_cur) + rx1086_fail: +.annotate 'line', 445 + (rx1086_rep, rx1086_pos, $I10, $P10) = rx1086_cur."!mark_fail"(0) + lt rx1086_pos, -1, rx1086_done + eq rx1086_pos, -1, rx1086_fail jump $I10 - rx1092_done: - rx1092_cur."!cursor_fail"() - rx1092_cur."!cursor_debug"("FAIL ", "infix:sym<~>") - .return (rx1092_cur) + rx1086_done: + rx1086_cur."!cursor_fail"() + rx1086_cur."!cursor_debug"("FAIL ", "infix:sym<*>") + .return (rx1086_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<~>" :subid("276_1275511697.61926") :method -.annotate 'line', 433 - $P1094 = self."!PREFIX__!subrule"("O", "~") - new $P1095, "ResizablePMCArray" - push $P1095, $P1094 - .return ($P1095) +.sub "!PREFIX__infix:sym<*>" :subid("275_1275600007.84296") :method +.annotate 'line', 445 + $P1088 = self."!PREFIX__!subrule"("O", "*") + new $P1089, "ResizablePMCArray" + push $P1089, $P1088 + .return ($P1089) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<==>" :subid("277_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1099_tgt - .local int rx1099_pos - .local int rx1099_off - .local int rx1099_eos - .local int rx1099_rep - .local pmc rx1099_cur - (rx1099_cur, rx1099_pos, rx1099_tgt) = self."!cursor_start"() - rx1099_cur."!cursor_debug"("START ", "infix:sym<==>") - .lex unicode:"$\x{a2}", rx1099_cur +.sub "infix:sym" :subid("276_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1093_tgt + .local int rx1093_pos + .local int rx1093_off + .local int rx1093_eos + .local int rx1093_rep + .local pmc rx1093_cur + (rx1093_cur, rx1093_pos, rx1093_tgt) = self."!cursor_start"() + rx1093_cur."!cursor_debug"("START ", "infix:sym") + .lex unicode:"$\x{a2}", rx1093_cur .local pmc match .lex "$/", match - length rx1099_eos, rx1099_tgt - gt rx1099_pos, rx1099_eos, rx1099_done - set rx1099_off, 0 - lt rx1099_pos, 2, rx1099_start - sub rx1099_off, rx1099_pos, 1 - substr rx1099_tgt, rx1099_tgt, rx1099_off - rx1099_start: + length rx1093_eos, rx1093_tgt + gt rx1093_pos, rx1093_eos, rx1093_done + set rx1093_off, 0 + lt rx1093_pos, 2, rx1093_start + sub rx1093_off, rx1093_pos, 1 + substr rx1093_tgt, rx1093_tgt, rx1093_off + rx1093_start: $I10 = self.'from'() - ne $I10, -1, rxscan1103_done - goto rxscan1103_scan - rxscan1103_loop: - ($P10) = rx1099_cur."from"() + ne $I10, -1, rxscan1097_done + goto rxscan1097_scan + rxscan1097_loop: + ($P10) = rx1093_cur."from"() inc $P10 - set rx1099_pos, $P10 - ge rx1099_pos, rx1099_eos, rxscan1103_done - rxscan1103_scan: - set_addr $I10, rxscan1103_loop - rx1099_cur."!mark_push"(0, rx1099_pos, $I10) - rxscan1103_done: -.annotate 'line', 502 + set rx1093_pos, $P10 + ge rx1093_pos, rx1093_eos, rxscan1097_done + rxscan1097_scan: + set_addr $I10, rxscan1097_loop + rx1093_cur."!mark_push"(0, rx1093_pos, $I10) + rxscan1097_done: +.annotate 'line', 506 # rx subcapture "sym" - set_addr $I10, rxcap_1104_fail - rx1099_cur."!mark_push"(0, rx1099_pos, $I10) - # rx literal "==" - add $I11, rx1099_pos, 2 - gt $I11, rx1099_eos, rx1099_fail - sub $I11, rx1099_pos, rx1099_off - substr $S10, rx1099_tgt, $I11, 2 - ne $S10, "==", rx1099_fail - add rx1099_pos, 2 - set_addr $I10, rxcap_1104_fail - ($I12, $I11) = rx1099_cur."!mark_peek"($I10) - rx1099_cur."!cursor_pos"($I11) - ($P10) = rx1099_cur."!cursor_start"() - $P10."!cursor_pass"(rx1099_pos, "") - rx1099_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1098_fail + rx1093_cur."!mark_push"(0, rx1093_pos, $I10) + # rx literal "/" + add $I11, rx1093_pos, 1 + gt $I11, rx1093_eos, rx1093_fail + sub $I11, rx1093_pos, rx1093_off + substr $S10, rx1093_tgt, $I11, 1 + ne $S10, "/", rx1093_fail + add rx1093_pos, 1 + set_addr $I10, rxcap_1098_fail + ($I12, $I11) = rx1093_cur."!mark_peek"($I10) + rx1093_cur."!cursor_pos"($I11) + ($P10) = rx1093_cur."!cursor_start"() + $P10."!cursor_pass"(rx1093_pos, "") + rx1093_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1104_done - rxcap_1104_fail: - goto rx1099_fail - rxcap_1104_done: + goto rxcap_1098_done + rxcap_1098_fail: + goto rx1093_fail + rxcap_1098_done: # rx subrule "O" subtype=capture negate= - rx1099_cur."!cursor_pos"(rx1099_pos) - $P10 = rx1099_cur."O"("%relational, :pirop") - unless $P10, rx1099_fail - rx1099_cur."!mark_push"(0, -1, 0, $P10) + rx1093_cur."!cursor_pos"(rx1093_pos) + $P10 = rx1093_cur."O"("%multiplicative, :pirop
") + unless $P10, rx1093_fail + rx1093_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1099_pos = $P10."pos"() + rx1093_pos = $P10."pos"() # rx pass - rx1099_cur."!cursor_pass"(rx1099_pos, "infix:sym<==>") - rx1099_cur."!cursor_debug"("PASS ", "infix:sym<==>", " at pos=", rx1099_pos) - .return (rx1099_cur) - rx1099_fail: -.annotate 'line', 433 - (rx1099_rep, rx1099_pos, $I10, $P10) = rx1099_cur."!mark_fail"(0) - lt rx1099_pos, -1, rx1099_done - eq rx1099_pos, -1, rx1099_fail + rx1093_cur."!cursor_pass"(rx1093_pos, "infix:sym") + rx1093_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1093_pos) + .return (rx1093_cur) + rx1093_fail: +.annotate 'line', 445 + (rx1093_rep, rx1093_pos, $I10, $P10) = rx1093_cur."!mark_fail"(0) + lt rx1093_pos, -1, rx1093_done + eq rx1093_pos, -1, rx1093_fail jump $I10 - rx1099_done: - rx1099_cur."!cursor_fail"() - rx1099_cur."!cursor_debug"("FAIL ", "infix:sym<==>") - .return (rx1099_cur) + rx1093_done: + rx1093_cur."!cursor_fail"() + rx1093_cur."!cursor_debug"("FAIL ", "infix:sym") + .return (rx1093_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<==>" :subid("278_1275511697.61926") :method -.annotate 'line', 433 - $P1101 = self."!PREFIX__!subrule"("O", "==") - new $P1102, "ResizablePMCArray" - push $P1102, $P1101 - .return ($P1102) +.sub "!PREFIX__infix:sym" :subid("277_1275600007.84296") :method +.annotate 'line', 445 + $P1095 = self."!PREFIX__!subrule"("O", "/") + new $P1096, "ResizablePMCArray" + push $P1096, $P1095 + .return ($P1096) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym" :subid("279_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1106_tgt - .local int rx1106_pos - .local int rx1106_off - .local int rx1106_eos - .local int rx1106_rep - .local pmc rx1106_cur - (rx1106_cur, rx1106_pos, rx1106_tgt) = self."!cursor_start"() - rx1106_cur."!cursor_debug"("START ", "infix:sym") - .lex unicode:"$\x{a2}", rx1106_cur +.sub "infix:sym<%>" :subid("278_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1100_tgt + .local int rx1100_pos + .local int rx1100_off + .local int rx1100_eos + .local int rx1100_rep + .local pmc rx1100_cur + (rx1100_cur, rx1100_pos, rx1100_tgt) = self."!cursor_start"() + rx1100_cur."!cursor_debug"("START ", "infix:sym<%>") + .lex unicode:"$\x{a2}", rx1100_cur .local pmc match .lex "$/", match - length rx1106_eos, rx1106_tgt - gt rx1106_pos, rx1106_eos, rx1106_done - set rx1106_off, 0 - lt rx1106_pos, 2, rx1106_start - sub rx1106_off, rx1106_pos, 1 - substr rx1106_tgt, rx1106_tgt, rx1106_off - rx1106_start: + length rx1100_eos, rx1100_tgt + gt rx1100_pos, rx1100_eos, rx1100_done + set rx1100_off, 0 + lt rx1100_pos, 2, rx1100_start + sub rx1100_off, rx1100_pos, 1 + substr rx1100_tgt, rx1100_tgt, rx1100_off + rx1100_start: $I10 = self.'from'() - ne $I10, -1, rxscan1110_done - goto rxscan1110_scan - rxscan1110_loop: - ($P10) = rx1106_cur."from"() + ne $I10, -1, rxscan1104_done + goto rxscan1104_scan + rxscan1104_loop: + ($P10) = rx1100_cur."from"() inc $P10 - set rx1106_pos, $P10 - ge rx1106_pos, rx1106_eos, rxscan1110_done - rxscan1110_scan: - set_addr $I10, rxscan1110_loop - rx1106_cur."!mark_push"(0, rx1106_pos, $I10) - rxscan1110_done: -.annotate 'line', 503 + set rx1100_pos, $P10 + ge rx1100_pos, rx1100_eos, rxscan1104_done + rxscan1104_scan: + set_addr $I10, rxscan1104_loop + rx1100_cur."!mark_push"(0, rx1100_pos, $I10) + rxscan1104_done: +.annotate 'line', 507 # rx subcapture "sym" - set_addr $I10, rxcap_1111_fail - rx1106_cur."!mark_push"(0, rx1106_pos, $I10) - # rx literal "!=" - add $I11, rx1106_pos, 2 - gt $I11, rx1106_eos, rx1106_fail - sub $I11, rx1106_pos, rx1106_off - substr $S10, rx1106_tgt, $I11, 2 - ne $S10, "!=", rx1106_fail - add rx1106_pos, 2 - set_addr $I10, rxcap_1111_fail - ($I12, $I11) = rx1106_cur."!mark_peek"($I10) - rx1106_cur."!cursor_pos"($I11) - ($P10) = rx1106_cur."!cursor_start"() - $P10."!cursor_pass"(rx1106_pos, "") - rx1106_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1105_fail + rx1100_cur."!mark_push"(0, rx1100_pos, $I10) + # rx literal "%" + add $I11, rx1100_pos, 1 + gt $I11, rx1100_eos, rx1100_fail + sub $I11, rx1100_pos, rx1100_off + substr $S10, rx1100_tgt, $I11, 1 + ne $S10, "%", rx1100_fail + add rx1100_pos, 1 + set_addr $I10, rxcap_1105_fail + ($I12, $I11) = rx1100_cur."!mark_peek"($I10) + rx1100_cur."!cursor_pos"($I11) + ($P10) = rx1100_cur."!cursor_start"() + $P10."!cursor_pass"(rx1100_pos, "") + rx1100_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1111_done - rxcap_1111_fail: - goto rx1106_fail - rxcap_1111_done: + goto rxcap_1105_done + rxcap_1105_fail: + goto rx1100_fail + rxcap_1105_done: # rx subrule "O" subtype=capture negate= - rx1106_cur."!cursor_pos"(rx1106_pos) - $P10 = rx1106_cur."O"("%relational, :pirop") - unless $P10, rx1106_fail - rx1106_cur."!mark_push"(0, -1, 0, $P10) + rx1100_cur."!cursor_pos"(rx1100_pos) + $P10 = rx1100_cur."O"("%multiplicative, :pirop") + unless $P10, rx1100_fail + rx1100_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1106_pos = $P10."pos"() + rx1100_pos = $P10."pos"() # rx pass - rx1106_cur."!cursor_pass"(rx1106_pos, "infix:sym") - rx1106_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1106_pos) - .return (rx1106_cur) - rx1106_fail: -.annotate 'line', 433 - (rx1106_rep, rx1106_pos, $I10, $P10) = rx1106_cur."!mark_fail"(0) - lt rx1106_pos, -1, rx1106_done - eq rx1106_pos, -1, rx1106_fail + rx1100_cur."!cursor_pass"(rx1100_pos, "infix:sym<%>") + rx1100_cur."!cursor_debug"("PASS ", "infix:sym<%>", " at pos=", rx1100_pos) + .return (rx1100_cur) + rx1100_fail: +.annotate 'line', 445 + (rx1100_rep, rx1100_pos, $I10, $P10) = rx1100_cur."!mark_fail"(0) + lt rx1100_pos, -1, rx1100_done + eq rx1100_pos, -1, rx1100_fail jump $I10 - rx1106_done: - rx1106_cur."!cursor_fail"() - rx1106_cur."!cursor_debug"("FAIL ", "infix:sym") - .return (rx1106_cur) + rx1100_done: + rx1100_cur."!cursor_fail"() + rx1100_cur."!cursor_debug"("FAIL ", "infix:sym<%>") + .return (rx1100_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym" :subid("280_1275511697.61926") :method -.annotate 'line', 433 - $P1108 = self."!PREFIX__!subrule"("O", "!=") - new $P1109, "ResizablePMCArray" - push $P1109, $P1108 - .return ($P1109) +.sub "!PREFIX__infix:sym<%>" :subid("279_1275600007.84296") :method +.annotate 'line', 445 + $P1102 = self."!PREFIX__!subrule"("O", "%") + new $P1103, "ResizablePMCArray" + push $P1103, $P1102 + .return ($P1103) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<<=>" :subid("281_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1113_tgt - .local int rx1113_pos - .local int rx1113_off - .local int rx1113_eos - .local int rx1113_rep - .local pmc rx1113_cur - (rx1113_cur, rx1113_pos, rx1113_tgt) = self."!cursor_start"() - rx1113_cur."!cursor_debug"("START ", "infix:sym<<=>") - .lex unicode:"$\x{a2}", rx1113_cur +.sub "infix:sym<+>" :subid("280_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1107_tgt + .local int rx1107_pos + .local int rx1107_off + .local int rx1107_eos + .local int rx1107_rep + .local pmc rx1107_cur + (rx1107_cur, rx1107_pos, rx1107_tgt) = self."!cursor_start"() + rx1107_cur."!cursor_debug"("START ", "infix:sym<+>") + .lex unicode:"$\x{a2}", rx1107_cur .local pmc match .lex "$/", match - length rx1113_eos, rx1113_tgt - gt rx1113_pos, rx1113_eos, rx1113_done - set rx1113_off, 0 - lt rx1113_pos, 2, rx1113_start - sub rx1113_off, rx1113_pos, 1 - substr rx1113_tgt, rx1113_tgt, rx1113_off - rx1113_start: + length rx1107_eos, rx1107_tgt + gt rx1107_pos, rx1107_eos, rx1107_done + set rx1107_off, 0 + lt rx1107_pos, 2, rx1107_start + sub rx1107_off, rx1107_pos, 1 + substr rx1107_tgt, rx1107_tgt, rx1107_off + rx1107_start: $I10 = self.'from'() - ne $I10, -1, rxscan1117_done - goto rxscan1117_scan - rxscan1117_loop: - ($P10) = rx1113_cur."from"() + ne $I10, -1, rxscan1111_done + goto rxscan1111_scan + rxscan1111_loop: + ($P10) = rx1107_cur."from"() inc $P10 - set rx1113_pos, $P10 - ge rx1113_pos, rx1113_eos, rxscan1117_done - rxscan1117_scan: - set_addr $I10, rxscan1117_loop - rx1113_cur."!mark_push"(0, rx1113_pos, $I10) - rxscan1117_done: -.annotate 'line', 504 + set rx1107_pos, $P10 + ge rx1107_pos, rx1107_eos, rxscan1111_done + rxscan1111_scan: + set_addr $I10, rxscan1111_loop + rx1107_cur."!mark_push"(0, rx1107_pos, $I10) + rxscan1111_done: +.annotate 'line', 509 # rx subcapture "sym" - set_addr $I10, rxcap_1118_fail - rx1113_cur."!mark_push"(0, rx1113_pos, $I10) - # rx literal "<=" - add $I11, rx1113_pos, 2 - gt $I11, rx1113_eos, rx1113_fail - sub $I11, rx1113_pos, rx1113_off - substr $S10, rx1113_tgt, $I11, 2 - ne $S10, "<=", rx1113_fail - add rx1113_pos, 2 - set_addr $I10, rxcap_1118_fail - ($I12, $I11) = rx1113_cur."!mark_peek"($I10) - rx1113_cur."!cursor_pos"($I11) - ($P10) = rx1113_cur."!cursor_start"() - $P10."!cursor_pass"(rx1113_pos, "") - rx1113_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1112_fail + rx1107_cur."!mark_push"(0, rx1107_pos, $I10) + # rx literal "+" + add $I11, rx1107_pos, 1 + gt $I11, rx1107_eos, rx1107_fail + sub $I11, rx1107_pos, rx1107_off + substr $S10, rx1107_tgt, $I11, 1 + ne $S10, "+", rx1107_fail + add rx1107_pos, 1 + set_addr $I10, rxcap_1112_fail + ($I12, $I11) = rx1107_cur."!mark_peek"($I10) + rx1107_cur."!cursor_pos"($I11) + ($P10) = rx1107_cur."!cursor_start"() + $P10."!cursor_pass"(rx1107_pos, "") + rx1107_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1118_done - rxcap_1118_fail: - goto rx1113_fail - rxcap_1118_done: + goto rxcap_1112_done + rxcap_1112_fail: + goto rx1107_fail + rxcap_1112_done: # rx subrule "O" subtype=capture negate= - rx1113_cur."!cursor_pos"(rx1113_pos) - $P10 = rx1113_cur."O"("%relational, :pirop") - unless $P10, rx1113_fail - rx1113_cur."!mark_push"(0, -1, 0, $P10) + rx1107_cur."!cursor_pos"(rx1107_pos) + $P10 = rx1107_cur."O"("%additive, :pirop") + unless $P10, rx1107_fail + rx1107_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1113_pos = $P10."pos"() + rx1107_pos = $P10."pos"() # rx pass - rx1113_cur."!cursor_pass"(rx1113_pos, "infix:sym<<=>") - rx1113_cur."!cursor_debug"("PASS ", "infix:sym<<=>", " at pos=", rx1113_pos) - .return (rx1113_cur) - rx1113_fail: -.annotate 'line', 433 - (rx1113_rep, rx1113_pos, $I10, $P10) = rx1113_cur."!mark_fail"(0) - lt rx1113_pos, -1, rx1113_done - eq rx1113_pos, -1, rx1113_fail + rx1107_cur."!cursor_pass"(rx1107_pos, "infix:sym<+>") + rx1107_cur."!cursor_debug"("PASS ", "infix:sym<+>", " at pos=", rx1107_pos) + .return (rx1107_cur) + rx1107_fail: +.annotate 'line', 445 + (rx1107_rep, rx1107_pos, $I10, $P10) = rx1107_cur."!mark_fail"(0) + lt rx1107_pos, -1, rx1107_done + eq rx1107_pos, -1, rx1107_fail jump $I10 - rx1113_done: - rx1113_cur."!cursor_fail"() - rx1113_cur."!cursor_debug"("FAIL ", "infix:sym<<=>") - .return (rx1113_cur) + rx1107_done: + rx1107_cur."!cursor_fail"() + rx1107_cur."!cursor_debug"("FAIL ", "infix:sym<+>") + .return (rx1107_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<<=>" :subid("282_1275511697.61926") :method -.annotate 'line', 433 - $P1115 = self."!PREFIX__!subrule"("O", "<=") - new $P1116, "ResizablePMCArray" - push $P1116, $P1115 - .return ($P1116) +.sub "!PREFIX__infix:sym<+>" :subid("281_1275600007.84296") :method +.annotate 'line', 445 + $P1109 = self."!PREFIX__!subrule"("O", "+") + new $P1110, "ResizablePMCArray" + push $P1110, $P1109 + .return ($P1110) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<>=>" :subid("283_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1120_tgt - .local int rx1120_pos - .local int rx1120_off - .local int rx1120_eos - .local int rx1120_rep - .local pmc rx1120_cur - (rx1120_cur, rx1120_pos, rx1120_tgt) = self."!cursor_start"() - rx1120_cur."!cursor_debug"("START ", "infix:sym<>=>") - .lex unicode:"$\x{a2}", rx1120_cur +.sub "infix:sym<->" :subid("282_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1114_tgt + .local int rx1114_pos + .local int rx1114_off + .local int rx1114_eos + .local int rx1114_rep + .local pmc rx1114_cur + (rx1114_cur, rx1114_pos, rx1114_tgt) = self."!cursor_start"() + rx1114_cur."!cursor_debug"("START ", "infix:sym<->") + .lex unicode:"$\x{a2}", rx1114_cur .local pmc match .lex "$/", match - length rx1120_eos, rx1120_tgt - gt rx1120_pos, rx1120_eos, rx1120_done - set rx1120_off, 0 - lt rx1120_pos, 2, rx1120_start - sub rx1120_off, rx1120_pos, 1 - substr rx1120_tgt, rx1120_tgt, rx1120_off - rx1120_start: + length rx1114_eos, rx1114_tgt + gt rx1114_pos, rx1114_eos, rx1114_done + set rx1114_off, 0 + lt rx1114_pos, 2, rx1114_start + sub rx1114_off, rx1114_pos, 1 + substr rx1114_tgt, rx1114_tgt, rx1114_off + rx1114_start: $I10 = self.'from'() - ne $I10, -1, rxscan1124_done - goto rxscan1124_scan - rxscan1124_loop: - ($P10) = rx1120_cur."from"() + ne $I10, -1, rxscan1118_done + goto rxscan1118_scan + rxscan1118_loop: + ($P10) = rx1114_cur."from"() inc $P10 - set rx1120_pos, $P10 - ge rx1120_pos, rx1120_eos, rxscan1124_done - rxscan1124_scan: - set_addr $I10, rxscan1124_loop - rx1120_cur."!mark_push"(0, rx1120_pos, $I10) - rxscan1124_done: -.annotate 'line', 505 + set rx1114_pos, $P10 + ge rx1114_pos, rx1114_eos, rxscan1118_done + rxscan1118_scan: + set_addr $I10, rxscan1118_loop + rx1114_cur."!mark_push"(0, rx1114_pos, $I10) + rxscan1118_done: +.annotate 'line', 510 # rx subcapture "sym" - set_addr $I10, rxcap_1125_fail - rx1120_cur."!mark_push"(0, rx1120_pos, $I10) - # rx literal ">=" - add $I11, rx1120_pos, 2 - gt $I11, rx1120_eos, rx1120_fail - sub $I11, rx1120_pos, rx1120_off - substr $S10, rx1120_tgt, $I11, 2 - ne $S10, ">=", rx1120_fail - add rx1120_pos, 2 - set_addr $I10, rxcap_1125_fail - ($I12, $I11) = rx1120_cur."!mark_peek"($I10) - rx1120_cur."!cursor_pos"($I11) - ($P10) = rx1120_cur."!cursor_start"() - $P10."!cursor_pass"(rx1120_pos, "") - rx1120_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1119_fail + rx1114_cur."!mark_push"(0, rx1114_pos, $I10) + # rx literal "-" + add $I11, rx1114_pos, 1 + gt $I11, rx1114_eos, rx1114_fail + sub $I11, rx1114_pos, rx1114_off + substr $S10, rx1114_tgt, $I11, 1 + ne $S10, "-", rx1114_fail + add rx1114_pos, 1 + set_addr $I10, rxcap_1119_fail + ($I12, $I11) = rx1114_cur."!mark_peek"($I10) + rx1114_cur."!cursor_pos"($I11) + ($P10) = rx1114_cur."!cursor_start"() + $P10."!cursor_pass"(rx1114_pos, "") + rx1114_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1125_done - rxcap_1125_fail: - goto rx1120_fail - rxcap_1125_done: + goto rxcap_1119_done + rxcap_1119_fail: + goto rx1114_fail + rxcap_1119_done: # rx subrule "O" subtype=capture negate= - rx1120_cur."!cursor_pos"(rx1120_pos) - $P10 = rx1120_cur."O"("%relational, :pirop") - unless $P10, rx1120_fail - rx1120_cur."!mark_push"(0, -1, 0, $P10) + rx1114_cur."!cursor_pos"(rx1114_pos) + $P10 = rx1114_cur."O"("%additive, :pirop") + unless $P10, rx1114_fail + rx1114_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1120_pos = $P10."pos"() + rx1114_pos = $P10."pos"() # rx pass - rx1120_cur."!cursor_pass"(rx1120_pos, "infix:sym<>=>") - rx1120_cur."!cursor_debug"("PASS ", "infix:sym<>=>", " at pos=", rx1120_pos) - .return (rx1120_cur) - rx1120_fail: -.annotate 'line', 433 - (rx1120_rep, rx1120_pos, $I10, $P10) = rx1120_cur."!mark_fail"(0) - lt rx1120_pos, -1, rx1120_done - eq rx1120_pos, -1, rx1120_fail + rx1114_cur."!cursor_pass"(rx1114_pos, "infix:sym<->") + rx1114_cur."!cursor_debug"("PASS ", "infix:sym<->", " at pos=", rx1114_pos) + .return (rx1114_cur) + rx1114_fail: +.annotate 'line', 445 + (rx1114_rep, rx1114_pos, $I10, $P10) = rx1114_cur."!mark_fail"(0) + lt rx1114_pos, -1, rx1114_done + eq rx1114_pos, -1, rx1114_fail jump $I10 - rx1120_done: - rx1120_cur."!cursor_fail"() - rx1120_cur."!cursor_debug"("FAIL ", "infix:sym<>=>") - .return (rx1120_cur) + rx1114_done: + rx1114_cur."!cursor_fail"() + rx1114_cur."!cursor_debug"("FAIL ", "infix:sym<->") + .return (rx1114_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<>=>" :subid("284_1275511697.61926") :method -.annotate 'line', 433 - $P1122 = self."!PREFIX__!subrule"("O", ">=") - new $P1123, "ResizablePMCArray" - push $P1123, $P1122 - .return ($P1123) +.sub "!PREFIX__infix:sym<->" :subid("283_1275600007.84296") :method +.annotate 'line', 445 + $P1116 = self."!PREFIX__!subrule"("O", "-") + new $P1117, "ResizablePMCArray" + push $P1117, $P1116 + .return ($P1117) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<<>" :subid("285_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1127_tgt - .local int rx1127_pos - .local int rx1127_off - .local int rx1127_eos - .local int rx1127_rep - .local pmc rx1127_cur - (rx1127_cur, rx1127_pos, rx1127_tgt) = self."!cursor_start"() - rx1127_cur."!cursor_debug"("START ", "infix:sym<<>") - .lex unicode:"$\x{a2}", rx1127_cur +.sub "infix:sym<~>" :subid("284_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1121_tgt + .local int rx1121_pos + .local int rx1121_off + .local int rx1121_eos + .local int rx1121_rep + .local pmc rx1121_cur + (rx1121_cur, rx1121_pos, rx1121_tgt) = self."!cursor_start"() + rx1121_cur."!cursor_debug"("START ", "infix:sym<~>") + .lex unicode:"$\x{a2}", rx1121_cur .local pmc match .lex "$/", match - length rx1127_eos, rx1127_tgt - gt rx1127_pos, rx1127_eos, rx1127_done - set rx1127_off, 0 - lt rx1127_pos, 2, rx1127_start - sub rx1127_off, rx1127_pos, 1 - substr rx1127_tgt, rx1127_tgt, rx1127_off - rx1127_start: + length rx1121_eos, rx1121_tgt + gt rx1121_pos, rx1121_eos, rx1121_done + set rx1121_off, 0 + lt rx1121_pos, 2, rx1121_start + sub rx1121_off, rx1121_pos, 1 + substr rx1121_tgt, rx1121_tgt, rx1121_off + rx1121_start: $I10 = self.'from'() - ne $I10, -1, rxscan1131_done - goto rxscan1131_scan - rxscan1131_loop: - ($P10) = rx1127_cur."from"() + ne $I10, -1, rxscan1125_done + goto rxscan1125_scan + rxscan1125_loop: + ($P10) = rx1121_cur."from"() inc $P10 - set rx1127_pos, $P10 - ge rx1127_pos, rx1127_eos, rxscan1131_done - rxscan1131_scan: - set_addr $I10, rxscan1131_loop - rx1127_cur."!mark_push"(0, rx1127_pos, $I10) - rxscan1131_done: -.annotate 'line', 506 + set rx1121_pos, $P10 + ge rx1121_pos, rx1121_eos, rxscan1125_done + rxscan1125_scan: + set_addr $I10, rxscan1125_loop + rx1121_cur."!mark_push"(0, rx1121_pos, $I10) + rxscan1125_done: +.annotate 'line', 512 # rx subcapture "sym" - set_addr $I10, rxcap_1132_fail - rx1127_cur."!mark_push"(0, rx1127_pos, $I10) - # rx literal "<" - add $I11, rx1127_pos, 1 - gt $I11, rx1127_eos, rx1127_fail - sub $I11, rx1127_pos, rx1127_off - substr $S10, rx1127_tgt, $I11, 1 - ne $S10, "<", rx1127_fail - add rx1127_pos, 1 - set_addr $I10, rxcap_1132_fail - ($I12, $I11) = rx1127_cur."!mark_peek"($I10) - rx1127_cur."!cursor_pos"($I11) - ($P10) = rx1127_cur."!cursor_start"() - $P10."!cursor_pass"(rx1127_pos, "") - rx1127_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1126_fail + rx1121_cur."!mark_push"(0, rx1121_pos, $I10) + # rx literal "~" + add $I11, rx1121_pos, 1 + gt $I11, rx1121_eos, rx1121_fail + sub $I11, rx1121_pos, rx1121_off + substr $S10, rx1121_tgt, $I11, 1 + ne $S10, "~", rx1121_fail + add rx1121_pos, 1 + set_addr $I10, rxcap_1126_fail + ($I12, $I11) = rx1121_cur."!mark_peek"($I10) + rx1121_cur."!cursor_pos"($I11) + ($P10) = rx1121_cur."!cursor_start"() + $P10."!cursor_pass"(rx1121_pos, "") + rx1121_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1132_done - rxcap_1132_fail: - goto rx1127_fail - rxcap_1132_done: + goto rxcap_1126_done + rxcap_1126_fail: + goto rx1121_fail + rxcap_1126_done: # rx subrule "O" subtype=capture negate= - rx1127_cur."!cursor_pos"(rx1127_pos) - $P10 = rx1127_cur."O"("%relational, :pirop") - unless $P10, rx1127_fail - rx1127_cur."!mark_push"(0, -1, 0, $P10) + rx1121_cur."!cursor_pos"(rx1121_pos) + $P10 = rx1121_cur."O"("%concatenation , :pirop") + unless $P10, rx1121_fail + rx1121_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1127_pos = $P10."pos"() + rx1121_pos = $P10."pos"() # rx pass - rx1127_cur."!cursor_pass"(rx1127_pos, "infix:sym<<>") - rx1127_cur."!cursor_debug"("PASS ", "infix:sym<<>", " at pos=", rx1127_pos) - .return (rx1127_cur) - rx1127_fail: -.annotate 'line', 433 - (rx1127_rep, rx1127_pos, $I10, $P10) = rx1127_cur."!mark_fail"(0) - lt rx1127_pos, -1, rx1127_done - eq rx1127_pos, -1, rx1127_fail + rx1121_cur."!cursor_pass"(rx1121_pos, "infix:sym<~>") + rx1121_cur."!cursor_debug"("PASS ", "infix:sym<~>", " at pos=", rx1121_pos) + .return (rx1121_cur) + rx1121_fail: +.annotate 'line', 445 + (rx1121_rep, rx1121_pos, $I10, $P10) = rx1121_cur."!mark_fail"(0) + lt rx1121_pos, -1, rx1121_done + eq rx1121_pos, -1, rx1121_fail jump $I10 - rx1127_done: - rx1127_cur."!cursor_fail"() - rx1127_cur."!cursor_debug"("FAIL ", "infix:sym<<>") - .return (rx1127_cur) + rx1121_done: + rx1121_cur."!cursor_fail"() + rx1121_cur."!cursor_debug"("FAIL ", "infix:sym<~>") + .return (rx1121_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<<>" :subid("286_1275511697.61926") :method -.annotate 'line', 433 - $P1129 = self."!PREFIX__!subrule"("O", "<") - new $P1130, "ResizablePMCArray" - push $P1130, $P1129 - .return ($P1130) +.sub "!PREFIX__infix:sym<~>" :subid("285_1275600007.84296") :method +.annotate 'line', 445 + $P1123 = self."!PREFIX__!subrule"("O", "~") + new $P1124, "ResizablePMCArray" + push $P1124, $P1123 + .return ($P1124) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<>>" :subid("287_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1134_tgt - .local int rx1134_pos - .local int rx1134_off - .local int rx1134_eos - .local int rx1134_rep - .local pmc rx1134_cur - (rx1134_cur, rx1134_pos, rx1134_tgt) = self."!cursor_start"() - rx1134_cur."!cursor_debug"("START ", "infix:sym<>>") - .lex unicode:"$\x{a2}", rx1134_cur +.sub "infix:sym<==>" :subid("286_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1128_tgt + .local int rx1128_pos + .local int rx1128_off + .local int rx1128_eos + .local int rx1128_rep + .local pmc rx1128_cur + (rx1128_cur, rx1128_pos, rx1128_tgt) = self."!cursor_start"() + rx1128_cur."!cursor_debug"("START ", "infix:sym<==>") + .lex unicode:"$\x{a2}", rx1128_cur .local pmc match .lex "$/", match - length rx1134_eos, rx1134_tgt - gt rx1134_pos, rx1134_eos, rx1134_done - set rx1134_off, 0 - lt rx1134_pos, 2, rx1134_start - sub rx1134_off, rx1134_pos, 1 - substr rx1134_tgt, rx1134_tgt, rx1134_off - rx1134_start: + length rx1128_eos, rx1128_tgt + gt rx1128_pos, rx1128_eos, rx1128_done + set rx1128_off, 0 + lt rx1128_pos, 2, rx1128_start + sub rx1128_off, rx1128_pos, 1 + substr rx1128_tgt, rx1128_tgt, rx1128_off + rx1128_start: $I10 = self.'from'() - ne $I10, -1, rxscan1138_done - goto rxscan1138_scan - rxscan1138_loop: - ($P10) = rx1134_cur."from"() + ne $I10, -1, rxscan1132_done + goto rxscan1132_scan + rxscan1132_loop: + ($P10) = rx1128_cur."from"() inc $P10 - set rx1134_pos, $P10 - ge rx1134_pos, rx1134_eos, rxscan1138_done - rxscan1138_scan: - set_addr $I10, rxscan1138_loop - rx1134_cur."!mark_push"(0, rx1134_pos, $I10) - rxscan1138_done: -.annotate 'line', 507 + set rx1128_pos, $P10 + ge rx1128_pos, rx1128_eos, rxscan1132_done + rxscan1132_scan: + set_addr $I10, rxscan1132_loop + rx1128_cur."!mark_push"(0, rx1128_pos, $I10) + rxscan1132_done: +.annotate 'line', 514 # rx subcapture "sym" - set_addr $I10, rxcap_1139_fail - rx1134_cur."!mark_push"(0, rx1134_pos, $I10) - # rx literal ">" - add $I11, rx1134_pos, 1 - gt $I11, rx1134_eos, rx1134_fail - sub $I11, rx1134_pos, rx1134_off - substr $S10, rx1134_tgt, $I11, 1 - ne $S10, ">", rx1134_fail - add rx1134_pos, 1 - set_addr $I10, rxcap_1139_fail - ($I12, $I11) = rx1134_cur."!mark_peek"($I10) - rx1134_cur."!cursor_pos"($I11) - ($P10) = rx1134_cur."!cursor_start"() - $P10."!cursor_pass"(rx1134_pos, "") - rx1134_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1133_fail + rx1128_cur."!mark_push"(0, rx1128_pos, $I10) + # rx literal "==" + add $I11, rx1128_pos, 2 + gt $I11, rx1128_eos, rx1128_fail + sub $I11, rx1128_pos, rx1128_off + substr $S10, rx1128_tgt, $I11, 2 + ne $S10, "==", rx1128_fail + add rx1128_pos, 2 + set_addr $I10, rxcap_1133_fail + ($I12, $I11) = rx1128_cur."!mark_peek"($I10) + rx1128_cur."!cursor_pos"($I11) + ($P10) = rx1128_cur."!cursor_start"() + $P10."!cursor_pass"(rx1128_pos, "") + rx1128_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1139_done - rxcap_1139_fail: - goto rx1134_fail - rxcap_1139_done: + goto rxcap_1133_done + rxcap_1133_fail: + goto rx1128_fail + rxcap_1133_done: # rx subrule "O" subtype=capture negate= - rx1134_cur."!cursor_pos"(rx1134_pos) - $P10 = rx1134_cur."O"("%relational, :pirop") - unless $P10, rx1134_fail - rx1134_cur."!mark_push"(0, -1, 0, $P10) + rx1128_cur."!cursor_pos"(rx1128_pos) + $P10 = rx1128_cur."O"("%relational, :pirop") + unless $P10, rx1128_fail + rx1128_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1134_pos = $P10."pos"() + rx1128_pos = $P10."pos"() # rx pass - rx1134_cur."!cursor_pass"(rx1134_pos, "infix:sym<>>") - rx1134_cur."!cursor_debug"("PASS ", "infix:sym<>>", " at pos=", rx1134_pos) - .return (rx1134_cur) - rx1134_fail: -.annotate 'line', 433 - (rx1134_rep, rx1134_pos, $I10, $P10) = rx1134_cur."!mark_fail"(0) - lt rx1134_pos, -1, rx1134_done - eq rx1134_pos, -1, rx1134_fail + rx1128_cur."!cursor_pass"(rx1128_pos, "infix:sym<==>") + rx1128_cur."!cursor_debug"("PASS ", "infix:sym<==>", " at pos=", rx1128_pos) + .return (rx1128_cur) + rx1128_fail: +.annotate 'line', 445 + (rx1128_rep, rx1128_pos, $I10, $P10) = rx1128_cur."!mark_fail"(0) + lt rx1128_pos, -1, rx1128_done + eq rx1128_pos, -1, rx1128_fail jump $I10 - rx1134_done: - rx1134_cur."!cursor_fail"() - rx1134_cur."!cursor_debug"("FAIL ", "infix:sym<>>") - .return (rx1134_cur) + rx1128_done: + rx1128_cur."!cursor_fail"() + rx1128_cur."!cursor_debug"("FAIL ", "infix:sym<==>") + .return (rx1128_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<>>" :subid("288_1275511697.61926") :method -.annotate 'line', 433 - $P1136 = self."!PREFIX__!subrule"("O", ">") - new $P1137, "ResizablePMCArray" - push $P1137, $P1136 - .return ($P1137) +.sub "!PREFIX__infix:sym<==>" :subid("287_1275600007.84296") :method +.annotate 'line', 445 + $P1130 = self."!PREFIX__!subrule"("O", "==") + new $P1131, "ResizablePMCArray" + push $P1131, $P1130 + .return ($P1131) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym" :subid("289_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1141_tgt - .local int rx1141_pos - .local int rx1141_off - .local int rx1141_eos - .local int rx1141_rep - .local pmc rx1141_cur - (rx1141_cur, rx1141_pos, rx1141_tgt) = self."!cursor_start"() - rx1141_cur."!cursor_debug"("START ", "infix:sym") - .lex unicode:"$\x{a2}", rx1141_cur +.sub "infix:sym" :subid("288_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1135_tgt + .local int rx1135_pos + .local int rx1135_off + .local int rx1135_eos + .local int rx1135_rep + .local pmc rx1135_cur + (rx1135_cur, rx1135_pos, rx1135_tgt) = self."!cursor_start"() + rx1135_cur."!cursor_debug"("START ", "infix:sym") + .lex unicode:"$\x{a2}", rx1135_cur .local pmc match .lex "$/", match - length rx1141_eos, rx1141_tgt - gt rx1141_pos, rx1141_eos, rx1141_done - set rx1141_off, 0 - lt rx1141_pos, 2, rx1141_start - sub rx1141_off, rx1141_pos, 1 - substr rx1141_tgt, rx1141_tgt, rx1141_off - rx1141_start: + length rx1135_eos, rx1135_tgt + gt rx1135_pos, rx1135_eos, rx1135_done + set rx1135_off, 0 + lt rx1135_pos, 2, rx1135_start + sub rx1135_off, rx1135_pos, 1 + substr rx1135_tgt, rx1135_tgt, rx1135_off + rx1135_start: $I10 = self.'from'() - ne $I10, -1, rxscan1145_done - goto rxscan1145_scan - rxscan1145_loop: - ($P10) = rx1141_cur."from"() + ne $I10, -1, rxscan1139_done + goto rxscan1139_scan + rxscan1139_loop: + ($P10) = rx1135_cur."from"() inc $P10 - set rx1141_pos, $P10 - ge rx1141_pos, rx1141_eos, rxscan1145_done - rxscan1145_scan: - set_addr $I10, rxscan1145_loop - rx1141_cur."!mark_push"(0, rx1141_pos, $I10) - rxscan1145_done: -.annotate 'line', 508 + set rx1135_pos, $P10 + ge rx1135_pos, rx1135_eos, rxscan1139_done + rxscan1139_scan: + set_addr $I10, rxscan1139_loop + rx1135_cur."!mark_push"(0, rx1135_pos, $I10) + rxscan1139_done: +.annotate 'line', 515 # rx subcapture "sym" - set_addr $I10, rxcap_1146_fail - rx1141_cur."!mark_push"(0, rx1141_pos, $I10) - # rx literal "eq" - add $I11, rx1141_pos, 2 - gt $I11, rx1141_eos, rx1141_fail - sub $I11, rx1141_pos, rx1141_off - substr $S10, rx1141_tgt, $I11, 2 - ne $S10, "eq", rx1141_fail - add rx1141_pos, 2 - set_addr $I10, rxcap_1146_fail - ($I12, $I11) = rx1141_cur."!mark_peek"($I10) - rx1141_cur."!cursor_pos"($I11) - ($P10) = rx1141_cur."!cursor_start"() - $P10."!cursor_pass"(rx1141_pos, "") - rx1141_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1140_fail + rx1135_cur."!mark_push"(0, rx1135_pos, $I10) + # rx literal "!=" + add $I11, rx1135_pos, 2 + gt $I11, rx1135_eos, rx1135_fail + sub $I11, rx1135_pos, rx1135_off + substr $S10, rx1135_tgt, $I11, 2 + ne $S10, "!=", rx1135_fail + add rx1135_pos, 2 + set_addr $I10, rxcap_1140_fail + ($I12, $I11) = rx1135_cur."!mark_peek"($I10) + rx1135_cur."!cursor_pos"($I11) + ($P10) = rx1135_cur."!cursor_start"() + $P10."!cursor_pass"(rx1135_pos, "") + rx1135_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1146_done - rxcap_1146_fail: - goto rx1141_fail - rxcap_1146_done: + goto rxcap_1140_done + rxcap_1140_fail: + goto rx1135_fail + rxcap_1140_done: # rx subrule "O" subtype=capture negate= - rx1141_cur."!cursor_pos"(rx1141_pos) - $P10 = rx1141_cur."O"("%relational, :pirop") - unless $P10, rx1141_fail - rx1141_cur."!mark_push"(0, -1, 0, $P10) + rx1135_cur."!cursor_pos"(rx1135_pos) + $P10 = rx1135_cur."O"("%relational, :pirop") + unless $P10, rx1135_fail + rx1135_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1141_pos = $P10."pos"() + rx1135_pos = $P10."pos"() # rx pass - rx1141_cur."!cursor_pass"(rx1141_pos, "infix:sym") - rx1141_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1141_pos) - .return (rx1141_cur) - rx1141_fail: -.annotate 'line', 433 - (rx1141_rep, rx1141_pos, $I10, $P10) = rx1141_cur."!mark_fail"(0) - lt rx1141_pos, -1, rx1141_done - eq rx1141_pos, -1, rx1141_fail + rx1135_cur."!cursor_pass"(rx1135_pos, "infix:sym") + rx1135_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1135_pos) + .return (rx1135_cur) + rx1135_fail: +.annotate 'line', 445 + (rx1135_rep, rx1135_pos, $I10, $P10) = rx1135_cur."!mark_fail"(0) + lt rx1135_pos, -1, rx1135_done + eq rx1135_pos, -1, rx1135_fail jump $I10 - rx1141_done: - rx1141_cur."!cursor_fail"() - rx1141_cur."!cursor_debug"("FAIL ", "infix:sym") - .return (rx1141_cur) + rx1135_done: + rx1135_cur."!cursor_fail"() + rx1135_cur."!cursor_debug"("FAIL ", "infix:sym") + .return (rx1135_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym" :subid("290_1275511697.61926") :method -.annotate 'line', 433 - $P1143 = self."!PREFIX__!subrule"("O", "eq") - new $P1144, "ResizablePMCArray" - push $P1144, $P1143 - .return ($P1144) +.sub "!PREFIX__infix:sym" :subid("289_1275600007.84296") :method +.annotate 'line', 445 + $P1137 = self."!PREFIX__!subrule"("O", "!=") + new $P1138, "ResizablePMCArray" + push $P1138, $P1137 + .return ($P1138) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym" :subid("291_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1148_tgt - .local int rx1148_pos - .local int rx1148_off - .local int rx1148_eos - .local int rx1148_rep - .local pmc rx1148_cur - (rx1148_cur, rx1148_pos, rx1148_tgt) = self."!cursor_start"() - rx1148_cur."!cursor_debug"("START ", "infix:sym") - .lex unicode:"$\x{a2}", rx1148_cur +.sub "infix:sym<<=>" :subid("290_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1142_tgt + .local int rx1142_pos + .local int rx1142_off + .local int rx1142_eos + .local int rx1142_rep + .local pmc rx1142_cur + (rx1142_cur, rx1142_pos, rx1142_tgt) = self."!cursor_start"() + rx1142_cur."!cursor_debug"("START ", "infix:sym<<=>") + .lex unicode:"$\x{a2}", rx1142_cur .local pmc match .lex "$/", match - length rx1148_eos, rx1148_tgt - gt rx1148_pos, rx1148_eos, rx1148_done - set rx1148_off, 0 - lt rx1148_pos, 2, rx1148_start - sub rx1148_off, rx1148_pos, 1 - substr rx1148_tgt, rx1148_tgt, rx1148_off - rx1148_start: + length rx1142_eos, rx1142_tgt + gt rx1142_pos, rx1142_eos, rx1142_done + set rx1142_off, 0 + lt rx1142_pos, 2, rx1142_start + sub rx1142_off, rx1142_pos, 1 + substr rx1142_tgt, rx1142_tgt, rx1142_off + rx1142_start: $I10 = self.'from'() - ne $I10, -1, rxscan1152_done - goto rxscan1152_scan - rxscan1152_loop: - ($P10) = rx1148_cur."from"() + ne $I10, -1, rxscan1146_done + goto rxscan1146_scan + rxscan1146_loop: + ($P10) = rx1142_cur."from"() inc $P10 - set rx1148_pos, $P10 - ge rx1148_pos, rx1148_eos, rxscan1152_done - rxscan1152_scan: - set_addr $I10, rxscan1152_loop - rx1148_cur."!mark_push"(0, rx1148_pos, $I10) - rxscan1152_done: -.annotate 'line', 509 + set rx1142_pos, $P10 + ge rx1142_pos, rx1142_eos, rxscan1146_done + rxscan1146_scan: + set_addr $I10, rxscan1146_loop + rx1142_cur."!mark_push"(0, rx1142_pos, $I10) + rxscan1146_done: +.annotate 'line', 516 # rx subcapture "sym" - set_addr $I10, rxcap_1153_fail - rx1148_cur."!mark_push"(0, rx1148_pos, $I10) - # rx literal "ne" - add $I11, rx1148_pos, 2 - gt $I11, rx1148_eos, rx1148_fail - sub $I11, rx1148_pos, rx1148_off - substr $S10, rx1148_tgt, $I11, 2 - ne $S10, "ne", rx1148_fail - add rx1148_pos, 2 - set_addr $I10, rxcap_1153_fail - ($I12, $I11) = rx1148_cur."!mark_peek"($I10) - rx1148_cur."!cursor_pos"($I11) - ($P10) = rx1148_cur."!cursor_start"() - $P10."!cursor_pass"(rx1148_pos, "") - rx1148_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1147_fail + rx1142_cur."!mark_push"(0, rx1142_pos, $I10) + # rx literal "<=" + add $I11, rx1142_pos, 2 + gt $I11, rx1142_eos, rx1142_fail + sub $I11, rx1142_pos, rx1142_off + substr $S10, rx1142_tgt, $I11, 2 + ne $S10, "<=", rx1142_fail + add rx1142_pos, 2 + set_addr $I10, rxcap_1147_fail + ($I12, $I11) = rx1142_cur."!mark_peek"($I10) + rx1142_cur."!cursor_pos"($I11) + ($P10) = rx1142_cur."!cursor_start"() + $P10."!cursor_pass"(rx1142_pos, "") + rx1142_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1153_done - rxcap_1153_fail: - goto rx1148_fail - rxcap_1153_done: + goto rxcap_1147_done + rxcap_1147_fail: + goto rx1142_fail + rxcap_1147_done: # rx subrule "O" subtype=capture negate= - rx1148_cur."!cursor_pos"(rx1148_pos) - $P10 = rx1148_cur."O"("%relational, :pirop") - unless $P10, rx1148_fail - rx1148_cur."!mark_push"(0, -1, 0, $P10) + rx1142_cur."!cursor_pos"(rx1142_pos) + $P10 = rx1142_cur."O"("%relational, :pirop") + unless $P10, rx1142_fail + rx1142_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1148_pos = $P10."pos"() + rx1142_pos = $P10."pos"() # rx pass - rx1148_cur."!cursor_pass"(rx1148_pos, "infix:sym") - rx1148_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1148_pos) - .return (rx1148_cur) - rx1148_fail: -.annotate 'line', 433 - (rx1148_rep, rx1148_pos, $I10, $P10) = rx1148_cur."!mark_fail"(0) - lt rx1148_pos, -1, rx1148_done - eq rx1148_pos, -1, rx1148_fail + rx1142_cur."!cursor_pass"(rx1142_pos, "infix:sym<<=>") + rx1142_cur."!cursor_debug"("PASS ", "infix:sym<<=>", " at pos=", rx1142_pos) + .return (rx1142_cur) + rx1142_fail: +.annotate 'line', 445 + (rx1142_rep, rx1142_pos, $I10, $P10) = rx1142_cur."!mark_fail"(0) + lt rx1142_pos, -1, rx1142_done + eq rx1142_pos, -1, rx1142_fail jump $I10 - rx1148_done: - rx1148_cur."!cursor_fail"() - rx1148_cur."!cursor_debug"("FAIL ", "infix:sym") - .return (rx1148_cur) + rx1142_done: + rx1142_cur."!cursor_fail"() + rx1142_cur."!cursor_debug"("FAIL ", "infix:sym<<=>") + .return (rx1142_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym" :subid("292_1275511697.61926") :method -.annotate 'line', 433 - $P1150 = self."!PREFIX__!subrule"("O", "ne") - new $P1151, "ResizablePMCArray" - push $P1151, $P1150 - .return ($P1151) +.sub "!PREFIX__infix:sym<<=>" :subid("291_1275600007.84296") :method +.annotate 'line', 445 + $P1144 = self."!PREFIX__!subrule"("O", "<=") + new $P1145, "ResizablePMCArray" + push $P1145, $P1144 + .return ($P1145) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym" :subid("293_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1155_tgt - .local int rx1155_pos - .local int rx1155_off - .local int rx1155_eos - .local int rx1155_rep - .local pmc rx1155_cur - (rx1155_cur, rx1155_pos, rx1155_tgt) = self."!cursor_start"() - rx1155_cur."!cursor_debug"("START ", "infix:sym") - .lex unicode:"$\x{a2}", rx1155_cur +.sub "infix:sym<>=>" :subid("292_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1149_tgt + .local int rx1149_pos + .local int rx1149_off + .local int rx1149_eos + .local int rx1149_rep + .local pmc rx1149_cur + (rx1149_cur, rx1149_pos, rx1149_tgt) = self."!cursor_start"() + rx1149_cur."!cursor_debug"("START ", "infix:sym<>=>") + .lex unicode:"$\x{a2}", rx1149_cur .local pmc match .lex "$/", match - length rx1155_eos, rx1155_tgt - gt rx1155_pos, rx1155_eos, rx1155_done - set rx1155_off, 0 - lt rx1155_pos, 2, rx1155_start - sub rx1155_off, rx1155_pos, 1 - substr rx1155_tgt, rx1155_tgt, rx1155_off - rx1155_start: + length rx1149_eos, rx1149_tgt + gt rx1149_pos, rx1149_eos, rx1149_done + set rx1149_off, 0 + lt rx1149_pos, 2, rx1149_start + sub rx1149_off, rx1149_pos, 1 + substr rx1149_tgt, rx1149_tgt, rx1149_off + rx1149_start: $I10 = self.'from'() - ne $I10, -1, rxscan1159_done - goto rxscan1159_scan - rxscan1159_loop: - ($P10) = rx1155_cur."from"() + ne $I10, -1, rxscan1153_done + goto rxscan1153_scan + rxscan1153_loop: + ($P10) = rx1149_cur."from"() inc $P10 - set rx1155_pos, $P10 - ge rx1155_pos, rx1155_eos, rxscan1159_done - rxscan1159_scan: - set_addr $I10, rxscan1159_loop - rx1155_cur."!mark_push"(0, rx1155_pos, $I10) - rxscan1159_done: -.annotate 'line', 510 + set rx1149_pos, $P10 + ge rx1149_pos, rx1149_eos, rxscan1153_done + rxscan1153_scan: + set_addr $I10, rxscan1153_loop + rx1149_cur."!mark_push"(0, rx1149_pos, $I10) + rxscan1153_done: +.annotate 'line', 517 # rx subcapture "sym" - set_addr $I10, rxcap_1160_fail - rx1155_cur."!mark_push"(0, rx1155_pos, $I10) - # rx literal "le" - add $I11, rx1155_pos, 2 - gt $I11, rx1155_eos, rx1155_fail - sub $I11, rx1155_pos, rx1155_off - substr $S10, rx1155_tgt, $I11, 2 - ne $S10, "le", rx1155_fail - add rx1155_pos, 2 - set_addr $I10, rxcap_1160_fail - ($I12, $I11) = rx1155_cur."!mark_peek"($I10) - rx1155_cur."!cursor_pos"($I11) - ($P10) = rx1155_cur."!cursor_start"() - $P10."!cursor_pass"(rx1155_pos, "") - rx1155_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1154_fail + rx1149_cur."!mark_push"(0, rx1149_pos, $I10) + # rx literal ">=" + add $I11, rx1149_pos, 2 + gt $I11, rx1149_eos, rx1149_fail + sub $I11, rx1149_pos, rx1149_off + substr $S10, rx1149_tgt, $I11, 2 + ne $S10, ">=", rx1149_fail + add rx1149_pos, 2 + set_addr $I10, rxcap_1154_fail + ($I12, $I11) = rx1149_cur."!mark_peek"($I10) + rx1149_cur."!cursor_pos"($I11) + ($P10) = rx1149_cur."!cursor_start"() + $P10."!cursor_pass"(rx1149_pos, "") + rx1149_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1160_done - rxcap_1160_fail: - goto rx1155_fail - rxcap_1160_done: + goto rxcap_1154_done + rxcap_1154_fail: + goto rx1149_fail + rxcap_1154_done: # rx subrule "O" subtype=capture negate= - rx1155_cur."!cursor_pos"(rx1155_pos) - $P10 = rx1155_cur."O"("%relational, :pirop") - unless $P10, rx1155_fail - rx1155_cur."!mark_push"(0, -1, 0, $P10) + rx1149_cur."!cursor_pos"(rx1149_pos) + $P10 = rx1149_cur."O"("%relational, :pirop") + unless $P10, rx1149_fail + rx1149_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1155_pos = $P10."pos"() + rx1149_pos = $P10."pos"() # rx pass - rx1155_cur."!cursor_pass"(rx1155_pos, "infix:sym") - rx1155_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1155_pos) - .return (rx1155_cur) - rx1155_fail: -.annotate 'line', 433 - (rx1155_rep, rx1155_pos, $I10, $P10) = rx1155_cur."!mark_fail"(0) - lt rx1155_pos, -1, rx1155_done - eq rx1155_pos, -1, rx1155_fail + rx1149_cur."!cursor_pass"(rx1149_pos, "infix:sym<>=>") + rx1149_cur."!cursor_debug"("PASS ", "infix:sym<>=>", " at pos=", rx1149_pos) + .return (rx1149_cur) + rx1149_fail: +.annotate 'line', 445 + (rx1149_rep, rx1149_pos, $I10, $P10) = rx1149_cur."!mark_fail"(0) + lt rx1149_pos, -1, rx1149_done + eq rx1149_pos, -1, rx1149_fail jump $I10 - rx1155_done: - rx1155_cur."!cursor_fail"() - rx1155_cur."!cursor_debug"("FAIL ", "infix:sym") - .return (rx1155_cur) + rx1149_done: + rx1149_cur."!cursor_fail"() + rx1149_cur."!cursor_debug"("FAIL ", "infix:sym<>=>") + .return (rx1149_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym" :subid("294_1275511697.61926") :method -.annotate 'line', 433 - $P1157 = self."!PREFIX__!subrule"("O", "le") - new $P1158, "ResizablePMCArray" - push $P1158, $P1157 - .return ($P1158) +.sub "!PREFIX__infix:sym<>=>" :subid("293_1275600007.84296") :method +.annotate 'line', 445 + $P1151 = self."!PREFIX__!subrule"("O", ">=") + new $P1152, "ResizablePMCArray" + push $P1152, $P1151 + .return ($P1152) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym" :subid("295_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1162_tgt - .local int rx1162_pos - .local int rx1162_off - .local int rx1162_eos - .local int rx1162_rep - .local pmc rx1162_cur - (rx1162_cur, rx1162_pos, rx1162_tgt) = self."!cursor_start"() - rx1162_cur."!cursor_debug"("START ", "infix:sym") - .lex unicode:"$\x{a2}", rx1162_cur +.sub "infix:sym<<>" :subid("294_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1156_tgt + .local int rx1156_pos + .local int rx1156_off + .local int rx1156_eos + .local int rx1156_rep + .local pmc rx1156_cur + (rx1156_cur, rx1156_pos, rx1156_tgt) = self."!cursor_start"() + rx1156_cur."!cursor_debug"("START ", "infix:sym<<>") + .lex unicode:"$\x{a2}", rx1156_cur .local pmc match .lex "$/", match - length rx1162_eos, rx1162_tgt - gt rx1162_pos, rx1162_eos, rx1162_done - set rx1162_off, 0 - lt rx1162_pos, 2, rx1162_start - sub rx1162_off, rx1162_pos, 1 - substr rx1162_tgt, rx1162_tgt, rx1162_off - rx1162_start: + length rx1156_eos, rx1156_tgt + gt rx1156_pos, rx1156_eos, rx1156_done + set rx1156_off, 0 + lt rx1156_pos, 2, rx1156_start + sub rx1156_off, rx1156_pos, 1 + substr rx1156_tgt, rx1156_tgt, rx1156_off + rx1156_start: $I10 = self.'from'() - ne $I10, -1, rxscan1166_done - goto rxscan1166_scan - rxscan1166_loop: - ($P10) = rx1162_cur."from"() + ne $I10, -1, rxscan1160_done + goto rxscan1160_scan + rxscan1160_loop: + ($P10) = rx1156_cur."from"() inc $P10 - set rx1162_pos, $P10 - ge rx1162_pos, rx1162_eos, rxscan1166_done - rxscan1166_scan: - set_addr $I10, rxscan1166_loop - rx1162_cur."!mark_push"(0, rx1162_pos, $I10) - rxscan1166_done: -.annotate 'line', 511 + set rx1156_pos, $P10 + ge rx1156_pos, rx1156_eos, rxscan1160_done + rxscan1160_scan: + set_addr $I10, rxscan1160_loop + rx1156_cur."!mark_push"(0, rx1156_pos, $I10) + rxscan1160_done: +.annotate 'line', 518 # rx subcapture "sym" - set_addr $I10, rxcap_1167_fail - rx1162_cur."!mark_push"(0, rx1162_pos, $I10) - # rx literal "ge" - add $I11, rx1162_pos, 2 - gt $I11, rx1162_eos, rx1162_fail - sub $I11, rx1162_pos, rx1162_off - substr $S10, rx1162_tgt, $I11, 2 - ne $S10, "ge", rx1162_fail - add rx1162_pos, 2 - set_addr $I10, rxcap_1167_fail - ($I12, $I11) = rx1162_cur."!mark_peek"($I10) - rx1162_cur."!cursor_pos"($I11) - ($P10) = rx1162_cur."!cursor_start"() - $P10."!cursor_pass"(rx1162_pos, "") - rx1162_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1161_fail + rx1156_cur."!mark_push"(0, rx1156_pos, $I10) + # rx literal "<" + add $I11, rx1156_pos, 1 + gt $I11, rx1156_eos, rx1156_fail + sub $I11, rx1156_pos, rx1156_off + substr $S10, rx1156_tgt, $I11, 1 + ne $S10, "<", rx1156_fail + add rx1156_pos, 1 + set_addr $I10, rxcap_1161_fail + ($I12, $I11) = rx1156_cur."!mark_peek"($I10) + rx1156_cur."!cursor_pos"($I11) + ($P10) = rx1156_cur."!cursor_start"() + $P10."!cursor_pass"(rx1156_pos, "") + rx1156_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1167_done - rxcap_1167_fail: - goto rx1162_fail - rxcap_1167_done: + goto rxcap_1161_done + rxcap_1161_fail: + goto rx1156_fail + rxcap_1161_done: # rx subrule "O" subtype=capture negate= - rx1162_cur."!cursor_pos"(rx1162_pos) - $P10 = rx1162_cur."O"("%relational, :pirop") - unless $P10, rx1162_fail - rx1162_cur."!mark_push"(0, -1, 0, $P10) + rx1156_cur."!cursor_pos"(rx1156_pos) + $P10 = rx1156_cur."O"("%relational, :pirop") + unless $P10, rx1156_fail + rx1156_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1162_pos = $P10."pos"() + rx1156_pos = $P10."pos"() # rx pass - rx1162_cur."!cursor_pass"(rx1162_pos, "infix:sym") - rx1162_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1162_pos) - .return (rx1162_cur) - rx1162_fail: -.annotate 'line', 433 - (rx1162_rep, rx1162_pos, $I10, $P10) = rx1162_cur."!mark_fail"(0) - lt rx1162_pos, -1, rx1162_done - eq rx1162_pos, -1, rx1162_fail + rx1156_cur."!cursor_pass"(rx1156_pos, "infix:sym<<>") + rx1156_cur."!cursor_debug"("PASS ", "infix:sym<<>", " at pos=", rx1156_pos) + .return (rx1156_cur) + rx1156_fail: +.annotate 'line', 445 + (rx1156_rep, rx1156_pos, $I10, $P10) = rx1156_cur."!mark_fail"(0) + lt rx1156_pos, -1, rx1156_done + eq rx1156_pos, -1, rx1156_fail jump $I10 - rx1162_done: - rx1162_cur."!cursor_fail"() - rx1162_cur."!cursor_debug"("FAIL ", "infix:sym") - .return (rx1162_cur) + rx1156_done: + rx1156_cur."!cursor_fail"() + rx1156_cur."!cursor_debug"("FAIL ", "infix:sym<<>") + .return (rx1156_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym" :subid("296_1275511697.61926") :method -.annotate 'line', 433 - $P1164 = self."!PREFIX__!subrule"("O", "ge") - new $P1165, "ResizablePMCArray" - push $P1165, $P1164 - .return ($P1165) +.sub "!PREFIX__infix:sym<<>" :subid("295_1275600007.84296") :method +.annotate 'line', 445 + $P1158 = self."!PREFIX__!subrule"("O", "<") + new $P1159, "ResizablePMCArray" + push $P1159, $P1158 + .return ($P1159) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym" :subid("297_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1169_tgt - .local int rx1169_pos - .local int rx1169_off - .local int rx1169_eos - .local int rx1169_rep - .local pmc rx1169_cur - (rx1169_cur, rx1169_pos, rx1169_tgt) = self."!cursor_start"() - rx1169_cur."!cursor_debug"("START ", "infix:sym") - .lex unicode:"$\x{a2}", rx1169_cur +.sub "infix:sym<>>" :subid("296_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1163_tgt + .local int rx1163_pos + .local int rx1163_off + .local int rx1163_eos + .local int rx1163_rep + .local pmc rx1163_cur + (rx1163_cur, rx1163_pos, rx1163_tgt) = self."!cursor_start"() + rx1163_cur."!cursor_debug"("START ", "infix:sym<>>") + .lex unicode:"$\x{a2}", rx1163_cur .local pmc match .lex "$/", match - length rx1169_eos, rx1169_tgt - gt rx1169_pos, rx1169_eos, rx1169_done - set rx1169_off, 0 - lt rx1169_pos, 2, rx1169_start - sub rx1169_off, rx1169_pos, 1 - substr rx1169_tgt, rx1169_tgt, rx1169_off - rx1169_start: + length rx1163_eos, rx1163_tgt + gt rx1163_pos, rx1163_eos, rx1163_done + set rx1163_off, 0 + lt rx1163_pos, 2, rx1163_start + sub rx1163_off, rx1163_pos, 1 + substr rx1163_tgt, rx1163_tgt, rx1163_off + rx1163_start: $I10 = self.'from'() - ne $I10, -1, rxscan1173_done - goto rxscan1173_scan - rxscan1173_loop: - ($P10) = rx1169_cur."from"() + ne $I10, -1, rxscan1167_done + goto rxscan1167_scan + rxscan1167_loop: + ($P10) = rx1163_cur."from"() inc $P10 - set rx1169_pos, $P10 - ge rx1169_pos, rx1169_eos, rxscan1173_done - rxscan1173_scan: - set_addr $I10, rxscan1173_loop - rx1169_cur."!mark_push"(0, rx1169_pos, $I10) - rxscan1173_done: -.annotate 'line', 512 + set rx1163_pos, $P10 + ge rx1163_pos, rx1163_eos, rxscan1167_done + rxscan1167_scan: + set_addr $I10, rxscan1167_loop + rx1163_cur."!mark_push"(0, rx1163_pos, $I10) + rxscan1167_done: +.annotate 'line', 519 # rx subcapture "sym" - set_addr $I10, rxcap_1174_fail - rx1169_cur."!mark_push"(0, rx1169_pos, $I10) - # rx literal "lt" - add $I11, rx1169_pos, 2 - gt $I11, rx1169_eos, rx1169_fail - sub $I11, rx1169_pos, rx1169_off - substr $S10, rx1169_tgt, $I11, 2 - ne $S10, "lt", rx1169_fail - add rx1169_pos, 2 - set_addr $I10, rxcap_1174_fail - ($I12, $I11) = rx1169_cur."!mark_peek"($I10) - rx1169_cur."!cursor_pos"($I11) - ($P10) = rx1169_cur."!cursor_start"() - $P10."!cursor_pass"(rx1169_pos, "") - rx1169_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1168_fail + rx1163_cur."!mark_push"(0, rx1163_pos, $I10) + # rx literal ">" + add $I11, rx1163_pos, 1 + gt $I11, rx1163_eos, rx1163_fail + sub $I11, rx1163_pos, rx1163_off + substr $S10, rx1163_tgt, $I11, 1 + ne $S10, ">", rx1163_fail + add rx1163_pos, 1 + set_addr $I10, rxcap_1168_fail + ($I12, $I11) = rx1163_cur."!mark_peek"($I10) + rx1163_cur."!cursor_pos"($I11) + ($P10) = rx1163_cur."!cursor_start"() + $P10."!cursor_pass"(rx1163_pos, "") + rx1163_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1174_done - rxcap_1174_fail: - goto rx1169_fail - rxcap_1174_done: + goto rxcap_1168_done + rxcap_1168_fail: + goto rx1163_fail + rxcap_1168_done: # rx subrule "O" subtype=capture negate= - rx1169_cur."!cursor_pos"(rx1169_pos) - $P10 = rx1169_cur."O"("%relational, :pirop") - unless $P10, rx1169_fail - rx1169_cur."!mark_push"(0, -1, 0, $P10) + rx1163_cur."!cursor_pos"(rx1163_pos) + $P10 = rx1163_cur."O"("%relational, :pirop") + unless $P10, rx1163_fail + rx1163_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1169_pos = $P10."pos"() + rx1163_pos = $P10."pos"() # rx pass - rx1169_cur."!cursor_pass"(rx1169_pos, "infix:sym") - rx1169_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1169_pos) - .return (rx1169_cur) - rx1169_fail: -.annotate 'line', 433 - (rx1169_rep, rx1169_pos, $I10, $P10) = rx1169_cur."!mark_fail"(0) - lt rx1169_pos, -1, rx1169_done - eq rx1169_pos, -1, rx1169_fail + rx1163_cur."!cursor_pass"(rx1163_pos, "infix:sym<>>") + rx1163_cur."!cursor_debug"("PASS ", "infix:sym<>>", " at pos=", rx1163_pos) + .return (rx1163_cur) + rx1163_fail: +.annotate 'line', 445 + (rx1163_rep, rx1163_pos, $I10, $P10) = rx1163_cur."!mark_fail"(0) + lt rx1163_pos, -1, rx1163_done + eq rx1163_pos, -1, rx1163_fail jump $I10 - rx1169_done: - rx1169_cur."!cursor_fail"() - rx1169_cur."!cursor_debug"("FAIL ", "infix:sym") - .return (rx1169_cur) + rx1163_done: + rx1163_cur."!cursor_fail"() + rx1163_cur."!cursor_debug"("FAIL ", "infix:sym<>>") + .return (rx1163_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym" :subid("298_1275511697.61926") :method -.annotate 'line', 433 - $P1171 = self."!PREFIX__!subrule"("O", "lt") - new $P1172, "ResizablePMCArray" - push $P1172, $P1171 - .return ($P1172) +.sub "!PREFIX__infix:sym<>>" :subid("297_1275600007.84296") :method +.annotate 'line', 445 + $P1165 = self."!PREFIX__!subrule"("O", ">") + new $P1166, "ResizablePMCArray" + push $P1166, $P1165 + .return ($P1166) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym" :subid("299_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1176_tgt - .local int rx1176_pos - .local int rx1176_off - .local int rx1176_eos - .local int rx1176_rep - .local pmc rx1176_cur - (rx1176_cur, rx1176_pos, rx1176_tgt) = self."!cursor_start"() - rx1176_cur."!cursor_debug"("START ", "infix:sym") - .lex unicode:"$\x{a2}", rx1176_cur +.sub "infix:sym" :subid("298_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1170_tgt + .local int rx1170_pos + .local int rx1170_off + .local int rx1170_eos + .local int rx1170_rep + .local pmc rx1170_cur + (rx1170_cur, rx1170_pos, rx1170_tgt) = self."!cursor_start"() + rx1170_cur."!cursor_debug"("START ", "infix:sym") + .lex unicode:"$\x{a2}", rx1170_cur .local pmc match .lex "$/", match - length rx1176_eos, rx1176_tgt - gt rx1176_pos, rx1176_eos, rx1176_done - set rx1176_off, 0 - lt rx1176_pos, 2, rx1176_start - sub rx1176_off, rx1176_pos, 1 - substr rx1176_tgt, rx1176_tgt, rx1176_off - rx1176_start: + length rx1170_eos, rx1170_tgt + gt rx1170_pos, rx1170_eos, rx1170_done + set rx1170_off, 0 + lt rx1170_pos, 2, rx1170_start + sub rx1170_off, rx1170_pos, 1 + substr rx1170_tgt, rx1170_tgt, rx1170_off + rx1170_start: $I10 = self.'from'() - ne $I10, -1, rxscan1180_done - goto rxscan1180_scan - rxscan1180_loop: - ($P10) = rx1176_cur."from"() + ne $I10, -1, rxscan1174_done + goto rxscan1174_scan + rxscan1174_loop: + ($P10) = rx1170_cur."from"() inc $P10 - set rx1176_pos, $P10 - ge rx1176_pos, rx1176_eos, rxscan1180_done - rxscan1180_scan: - set_addr $I10, rxscan1180_loop - rx1176_cur."!mark_push"(0, rx1176_pos, $I10) - rxscan1180_done: -.annotate 'line', 513 + set rx1170_pos, $P10 + ge rx1170_pos, rx1170_eos, rxscan1174_done + rxscan1174_scan: + set_addr $I10, rxscan1174_loop + rx1170_cur."!mark_push"(0, rx1170_pos, $I10) + rxscan1174_done: +.annotate 'line', 520 # rx subcapture "sym" - set_addr $I10, rxcap_1181_fail - rx1176_cur."!mark_push"(0, rx1176_pos, $I10) - # rx literal "gt" - add $I11, rx1176_pos, 2 - gt $I11, rx1176_eos, rx1176_fail - sub $I11, rx1176_pos, rx1176_off - substr $S10, rx1176_tgt, $I11, 2 - ne $S10, "gt", rx1176_fail - add rx1176_pos, 2 - set_addr $I10, rxcap_1181_fail - ($I12, $I11) = rx1176_cur."!mark_peek"($I10) - rx1176_cur."!cursor_pos"($I11) - ($P10) = rx1176_cur."!cursor_start"() - $P10."!cursor_pass"(rx1176_pos, "") - rx1176_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1175_fail + rx1170_cur."!mark_push"(0, rx1170_pos, $I10) + # rx literal "eq" + add $I11, rx1170_pos, 2 + gt $I11, rx1170_eos, rx1170_fail + sub $I11, rx1170_pos, rx1170_off + substr $S10, rx1170_tgt, $I11, 2 + ne $S10, "eq", rx1170_fail + add rx1170_pos, 2 + set_addr $I10, rxcap_1175_fail + ($I12, $I11) = rx1170_cur."!mark_peek"($I10) + rx1170_cur."!cursor_pos"($I11) + ($P10) = rx1170_cur."!cursor_start"() + $P10."!cursor_pass"(rx1170_pos, "") + rx1170_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1181_done - rxcap_1181_fail: - goto rx1176_fail - rxcap_1181_done: + goto rxcap_1175_done + rxcap_1175_fail: + goto rx1170_fail + rxcap_1175_done: # rx subrule "O" subtype=capture negate= - rx1176_cur."!cursor_pos"(rx1176_pos) - $P10 = rx1176_cur."O"("%relational, :pirop") - unless $P10, rx1176_fail - rx1176_cur."!mark_push"(0, -1, 0, $P10) + rx1170_cur."!cursor_pos"(rx1170_pos) + $P10 = rx1170_cur."O"("%relational, :pirop") + unless $P10, rx1170_fail + rx1170_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1176_pos = $P10."pos"() + rx1170_pos = $P10."pos"() # rx pass - rx1176_cur."!cursor_pass"(rx1176_pos, "infix:sym") - rx1176_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1176_pos) - .return (rx1176_cur) - rx1176_fail: -.annotate 'line', 433 - (rx1176_rep, rx1176_pos, $I10, $P10) = rx1176_cur."!mark_fail"(0) - lt rx1176_pos, -1, rx1176_done - eq rx1176_pos, -1, rx1176_fail + rx1170_cur."!cursor_pass"(rx1170_pos, "infix:sym") + rx1170_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1170_pos) + .return (rx1170_cur) + rx1170_fail: +.annotate 'line', 445 + (rx1170_rep, rx1170_pos, $I10, $P10) = rx1170_cur."!mark_fail"(0) + lt rx1170_pos, -1, rx1170_done + eq rx1170_pos, -1, rx1170_fail jump $I10 - rx1176_done: - rx1176_cur."!cursor_fail"() - rx1176_cur."!cursor_debug"("FAIL ", "infix:sym") - .return (rx1176_cur) + rx1170_done: + rx1170_cur."!cursor_fail"() + rx1170_cur."!cursor_debug"("FAIL ", "infix:sym") + .return (rx1170_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym" :subid("300_1275511697.61926") :method -.annotate 'line', 433 - $P1178 = self."!PREFIX__!subrule"("O", "gt") - new $P1179, "ResizablePMCArray" - push $P1179, $P1178 - .return ($P1179) +.sub "!PREFIX__infix:sym" :subid("299_1275600007.84296") :method +.annotate 'line', 445 + $P1172 = self."!PREFIX__!subrule"("O", "eq") + new $P1173, "ResizablePMCArray" + push $P1173, $P1172 + .return ($P1173) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<=:=>" :subid("301_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1183_tgt - .local int rx1183_pos - .local int rx1183_off - .local int rx1183_eos - .local int rx1183_rep - .local pmc rx1183_cur - (rx1183_cur, rx1183_pos, rx1183_tgt) = self."!cursor_start"() - rx1183_cur."!cursor_debug"("START ", "infix:sym<=:=>") - .lex unicode:"$\x{a2}", rx1183_cur +.sub "infix:sym" :subid("300_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1177_tgt + .local int rx1177_pos + .local int rx1177_off + .local int rx1177_eos + .local int rx1177_rep + .local pmc rx1177_cur + (rx1177_cur, rx1177_pos, rx1177_tgt) = self."!cursor_start"() + rx1177_cur."!cursor_debug"("START ", "infix:sym") + .lex unicode:"$\x{a2}", rx1177_cur .local pmc match .lex "$/", match - length rx1183_eos, rx1183_tgt - gt rx1183_pos, rx1183_eos, rx1183_done - set rx1183_off, 0 - lt rx1183_pos, 2, rx1183_start - sub rx1183_off, rx1183_pos, 1 - substr rx1183_tgt, rx1183_tgt, rx1183_off - rx1183_start: + length rx1177_eos, rx1177_tgt + gt rx1177_pos, rx1177_eos, rx1177_done + set rx1177_off, 0 + lt rx1177_pos, 2, rx1177_start + sub rx1177_off, rx1177_pos, 1 + substr rx1177_tgt, rx1177_tgt, rx1177_off + rx1177_start: $I10 = self.'from'() - ne $I10, -1, rxscan1187_done - goto rxscan1187_scan - rxscan1187_loop: - ($P10) = rx1183_cur."from"() + ne $I10, -1, rxscan1181_done + goto rxscan1181_scan + rxscan1181_loop: + ($P10) = rx1177_cur."from"() inc $P10 - set rx1183_pos, $P10 - ge rx1183_pos, rx1183_eos, rxscan1187_done - rxscan1187_scan: - set_addr $I10, rxscan1187_loop - rx1183_cur."!mark_push"(0, rx1183_pos, $I10) - rxscan1187_done: -.annotate 'line', 514 + set rx1177_pos, $P10 + ge rx1177_pos, rx1177_eos, rxscan1181_done + rxscan1181_scan: + set_addr $I10, rxscan1181_loop + rx1177_cur."!mark_push"(0, rx1177_pos, $I10) + rxscan1181_done: +.annotate 'line', 521 # rx subcapture "sym" - set_addr $I10, rxcap_1188_fail - rx1183_cur."!mark_push"(0, rx1183_pos, $I10) - # rx literal "=:=" - add $I11, rx1183_pos, 3 - gt $I11, rx1183_eos, rx1183_fail - sub $I11, rx1183_pos, rx1183_off - substr $S10, rx1183_tgt, $I11, 3 - ne $S10, "=:=", rx1183_fail - add rx1183_pos, 3 - set_addr $I10, rxcap_1188_fail - ($I12, $I11) = rx1183_cur."!mark_peek"($I10) - rx1183_cur."!cursor_pos"($I11) - ($P10) = rx1183_cur."!cursor_start"() - $P10."!cursor_pass"(rx1183_pos, "") - rx1183_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1182_fail + rx1177_cur."!mark_push"(0, rx1177_pos, $I10) + # rx literal "ne" + add $I11, rx1177_pos, 2 + gt $I11, rx1177_eos, rx1177_fail + sub $I11, rx1177_pos, rx1177_off + substr $S10, rx1177_tgt, $I11, 2 + ne $S10, "ne", rx1177_fail + add rx1177_pos, 2 + set_addr $I10, rxcap_1182_fail + ($I12, $I11) = rx1177_cur."!mark_peek"($I10) + rx1177_cur."!cursor_pos"($I11) + ($P10) = rx1177_cur."!cursor_start"() + $P10."!cursor_pass"(rx1177_pos, "") + rx1177_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1188_done - rxcap_1188_fail: - goto rx1183_fail - rxcap_1188_done: + goto rxcap_1182_done + rxcap_1182_fail: + goto rx1177_fail + rxcap_1182_done: # rx subrule "O" subtype=capture negate= - rx1183_cur."!cursor_pos"(rx1183_pos) - $P10 = rx1183_cur."O"("%relational, :pirop") - unless $P10, rx1183_fail - rx1183_cur."!mark_push"(0, -1, 0, $P10) + rx1177_cur."!cursor_pos"(rx1177_pos) + $P10 = rx1177_cur."O"("%relational, :pirop") + unless $P10, rx1177_fail + rx1177_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1183_pos = $P10."pos"() + rx1177_pos = $P10."pos"() # rx pass - rx1183_cur."!cursor_pass"(rx1183_pos, "infix:sym<=:=>") - rx1183_cur."!cursor_debug"("PASS ", "infix:sym<=:=>", " at pos=", rx1183_pos) - .return (rx1183_cur) - rx1183_fail: -.annotate 'line', 433 - (rx1183_rep, rx1183_pos, $I10, $P10) = rx1183_cur."!mark_fail"(0) - lt rx1183_pos, -1, rx1183_done - eq rx1183_pos, -1, rx1183_fail + rx1177_cur."!cursor_pass"(rx1177_pos, "infix:sym") + rx1177_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1177_pos) + .return (rx1177_cur) + rx1177_fail: +.annotate 'line', 445 + (rx1177_rep, rx1177_pos, $I10, $P10) = rx1177_cur."!mark_fail"(0) + lt rx1177_pos, -1, rx1177_done + eq rx1177_pos, -1, rx1177_fail jump $I10 - rx1183_done: - rx1183_cur."!cursor_fail"() - rx1183_cur."!cursor_debug"("FAIL ", "infix:sym<=:=>") - .return (rx1183_cur) + rx1177_done: + rx1177_cur."!cursor_fail"() + rx1177_cur."!cursor_debug"("FAIL ", "infix:sym") + .return (rx1177_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<=:=>" :subid("302_1275511697.61926") :method -.annotate 'line', 433 - $P1185 = self."!PREFIX__!subrule"("O", "=:=") - new $P1186, "ResizablePMCArray" - push $P1186, $P1185 - .return ($P1186) +.sub "!PREFIX__infix:sym" :subid("301_1275600007.84296") :method +.annotate 'line', 445 + $P1179 = self."!PREFIX__!subrule"("O", "ne") + new $P1180, "ResizablePMCArray" + push $P1180, $P1179 + .return ($P1180) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<~~>" :subid("303_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1190_tgt - .local int rx1190_pos - .local int rx1190_off - .local int rx1190_eos - .local int rx1190_rep - .local pmc rx1190_cur - (rx1190_cur, rx1190_pos, rx1190_tgt) = self."!cursor_start"() - rx1190_cur."!cursor_debug"("START ", "infix:sym<~~>") - .lex unicode:"$\x{a2}", rx1190_cur +.sub "infix:sym" :subid("302_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1184_tgt + .local int rx1184_pos + .local int rx1184_off + .local int rx1184_eos + .local int rx1184_rep + .local pmc rx1184_cur + (rx1184_cur, rx1184_pos, rx1184_tgt) = self."!cursor_start"() + rx1184_cur."!cursor_debug"("START ", "infix:sym") + .lex unicode:"$\x{a2}", rx1184_cur .local pmc match .lex "$/", match - length rx1190_eos, rx1190_tgt - gt rx1190_pos, rx1190_eos, rx1190_done - set rx1190_off, 0 - lt rx1190_pos, 2, rx1190_start - sub rx1190_off, rx1190_pos, 1 - substr rx1190_tgt, rx1190_tgt, rx1190_off - rx1190_start: + length rx1184_eos, rx1184_tgt + gt rx1184_pos, rx1184_eos, rx1184_done + set rx1184_off, 0 + lt rx1184_pos, 2, rx1184_start + sub rx1184_off, rx1184_pos, 1 + substr rx1184_tgt, rx1184_tgt, rx1184_off + rx1184_start: $I10 = self.'from'() - ne $I10, -1, rxscan1194_done - goto rxscan1194_scan - rxscan1194_loop: - ($P10) = rx1190_cur."from"() + ne $I10, -1, rxscan1188_done + goto rxscan1188_scan + rxscan1188_loop: + ($P10) = rx1184_cur."from"() inc $P10 - set rx1190_pos, $P10 - ge rx1190_pos, rx1190_eos, rxscan1194_done - rxscan1194_scan: - set_addr $I10, rxscan1194_loop - rx1190_cur."!mark_push"(0, rx1190_pos, $I10) - rxscan1194_done: -.annotate 'line', 515 + set rx1184_pos, $P10 + ge rx1184_pos, rx1184_eos, rxscan1188_done + rxscan1188_scan: + set_addr $I10, rxscan1188_loop + rx1184_cur."!mark_push"(0, rx1184_pos, $I10) + rxscan1188_done: +.annotate 'line', 522 # rx subcapture "sym" - set_addr $I10, rxcap_1195_fail - rx1190_cur."!mark_push"(0, rx1190_pos, $I10) - # rx literal "~~" - add $I11, rx1190_pos, 2 - gt $I11, rx1190_eos, rx1190_fail - sub $I11, rx1190_pos, rx1190_off - substr $S10, rx1190_tgt, $I11, 2 - ne $S10, "~~", rx1190_fail - add rx1190_pos, 2 - set_addr $I10, rxcap_1195_fail - ($I12, $I11) = rx1190_cur."!mark_peek"($I10) - rx1190_cur."!cursor_pos"($I11) - ($P10) = rx1190_cur."!cursor_start"() - $P10."!cursor_pass"(rx1190_pos, "") - rx1190_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1189_fail + rx1184_cur."!mark_push"(0, rx1184_pos, $I10) + # rx literal "le" + add $I11, rx1184_pos, 2 + gt $I11, rx1184_eos, rx1184_fail + sub $I11, rx1184_pos, rx1184_off + substr $S10, rx1184_tgt, $I11, 2 + ne $S10, "le", rx1184_fail + add rx1184_pos, 2 + set_addr $I10, rxcap_1189_fail + ($I12, $I11) = rx1184_cur."!mark_peek"($I10) + rx1184_cur."!cursor_pos"($I11) + ($P10) = rx1184_cur."!cursor_start"() + $P10."!cursor_pass"(rx1184_pos, "") + rx1184_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1195_done - rxcap_1195_fail: - goto rx1190_fail - rxcap_1195_done: + goto rxcap_1189_done + rxcap_1189_fail: + goto rx1184_fail + rxcap_1189_done: # rx subrule "O" subtype=capture negate= - rx1190_cur."!cursor_pos"(rx1190_pos) - $P10 = rx1190_cur."O"("%relational, :reducecheck") - unless $P10, rx1190_fail - rx1190_cur."!mark_push"(0, -1, 0, $P10) + rx1184_cur."!cursor_pos"(rx1184_pos) + $P10 = rx1184_cur."O"("%relational, :pirop") + unless $P10, rx1184_fail + rx1184_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1190_pos = $P10."pos"() + rx1184_pos = $P10."pos"() # rx pass - rx1190_cur."!cursor_pass"(rx1190_pos, "infix:sym<~~>") - rx1190_cur."!cursor_debug"("PASS ", "infix:sym<~~>", " at pos=", rx1190_pos) - .return (rx1190_cur) - rx1190_fail: -.annotate 'line', 433 - (rx1190_rep, rx1190_pos, $I10, $P10) = rx1190_cur."!mark_fail"(0) - lt rx1190_pos, -1, rx1190_done - eq rx1190_pos, -1, rx1190_fail + rx1184_cur."!cursor_pass"(rx1184_pos, "infix:sym") + rx1184_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1184_pos) + .return (rx1184_cur) + rx1184_fail: +.annotate 'line', 445 + (rx1184_rep, rx1184_pos, $I10, $P10) = rx1184_cur."!mark_fail"(0) + lt rx1184_pos, -1, rx1184_done + eq rx1184_pos, -1, rx1184_fail jump $I10 - rx1190_done: - rx1190_cur."!cursor_fail"() - rx1190_cur."!cursor_debug"("FAIL ", "infix:sym<~~>") - .return (rx1190_cur) + rx1184_done: + rx1184_cur."!cursor_fail"() + rx1184_cur."!cursor_debug"("FAIL ", "infix:sym") + .return (rx1184_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<~~>" :subid("304_1275511697.61926") :method -.annotate 'line', 433 - $P1192 = self."!PREFIX__!subrule"("O", "~~") - new $P1193, "ResizablePMCArray" - push $P1193, $P1192 - .return ($P1193) +.sub "!PREFIX__infix:sym" :subid("303_1275600007.84296") :method +.annotate 'line', 445 + $P1186 = self."!PREFIX__!subrule"("O", "le") + new $P1187, "ResizablePMCArray" + push $P1187, $P1186 + .return ($P1187) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<&&>" :subid("305_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1197_tgt - .local int rx1197_pos - .local int rx1197_off - .local int rx1197_eos - .local int rx1197_rep - .local pmc rx1197_cur - (rx1197_cur, rx1197_pos, rx1197_tgt) = self."!cursor_start"() - rx1197_cur."!cursor_debug"("START ", "infix:sym<&&>") - .lex unicode:"$\x{a2}", rx1197_cur +.sub "infix:sym" :subid("304_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1191_tgt + .local int rx1191_pos + .local int rx1191_off + .local int rx1191_eos + .local int rx1191_rep + .local pmc rx1191_cur + (rx1191_cur, rx1191_pos, rx1191_tgt) = self."!cursor_start"() + rx1191_cur."!cursor_debug"("START ", "infix:sym") + .lex unicode:"$\x{a2}", rx1191_cur .local pmc match .lex "$/", match - length rx1197_eos, rx1197_tgt - gt rx1197_pos, rx1197_eos, rx1197_done - set rx1197_off, 0 - lt rx1197_pos, 2, rx1197_start - sub rx1197_off, rx1197_pos, 1 - substr rx1197_tgt, rx1197_tgt, rx1197_off - rx1197_start: + length rx1191_eos, rx1191_tgt + gt rx1191_pos, rx1191_eos, rx1191_done + set rx1191_off, 0 + lt rx1191_pos, 2, rx1191_start + sub rx1191_off, rx1191_pos, 1 + substr rx1191_tgt, rx1191_tgt, rx1191_off + rx1191_start: $I10 = self.'from'() - ne $I10, -1, rxscan1201_done - goto rxscan1201_scan - rxscan1201_loop: - ($P10) = rx1197_cur."from"() + ne $I10, -1, rxscan1195_done + goto rxscan1195_scan + rxscan1195_loop: + ($P10) = rx1191_cur."from"() inc $P10 - set rx1197_pos, $P10 - ge rx1197_pos, rx1197_eos, rxscan1201_done - rxscan1201_scan: - set_addr $I10, rxscan1201_loop - rx1197_cur."!mark_push"(0, rx1197_pos, $I10) - rxscan1201_done: -.annotate 'line', 517 + set rx1191_pos, $P10 + ge rx1191_pos, rx1191_eos, rxscan1195_done + rxscan1195_scan: + set_addr $I10, rxscan1195_loop + rx1191_cur."!mark_push"(0, rx1191_pos, $I10) + rxscan1195_done: +.annotate 'line', 523 # rx subcapture "sym" - set_addr $I10, rxcap_1202_fail - rx1197_cur."!mark_push"(0, rx1197_pos, $I10) - # rx literal "&&" - add $I11, rx1197_pos, 2 - gt $I11, rx1197_eos, rx1197_fail - sub $I11, rx1197_pos, rx1197_off - substr $S10, rx1197_tgt, $I11, 2 - ne $S10, "&&", rx1197_fail - add rx1197_pos, 2 - set_addr $I10, rxcap_1202_fail - ($I12, $I11) = rx1197_cur."!mark_peek"($I10) - rx1197_cur."!cursor_pos"($I11) - ($P10) = rx1197_cur."!cursor_start"() - $P10."!cursor_pass"(rx1197_pos, "") - rx1197_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1196_fail + rx1191_cur."!mark_push"(0, rx1191_pos, $I10) + # rx literal "ge" + add $I11, rx1191_pos, 2 + gt $I11, rx1191_eos, rx1191_fail + sub $I11, rx1191_pos, rx1191_off + substr $S10, rx1191_tgt, $I11, 2 + ne $S10, "ge", rx1191_fail + add rx1191_pos, 2 + set_addr $I10, rxcap_1196_fail + ($I12, $I11) = rx1191_cur."!mark_peek"($I10) + rx1191_cur."!cursor_pos"($I11) + ($P10) = rx1191_cur."!cursor_start"() + $P10."!cursor_pass"(rx1191_pos, "") + rx1191_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1202_done - rxcap_1202_fail: - goto rx1197_fail - rxcap_1202_done: + goto rxcap_1196_done + rxcap_1196_fail: + goto rx1191_fail + rxcap_1196_done: # rx subrule "O" subtype=capture negate= - rx1197_cur."!cursor_pos"(rx1197_pos) - $P10 = rx1197_cur."O"("%tight_and, :pasttype") - unless $P10, rx1197_fail - rx1197_cur."!mark_push"(0, -1, 0, $P10) + rx1191_cur."!cursor_pos"(rx1191_pos) + $P10 = rx1191_cur."O"("%relational, :pirop") + unless $P10, rx1191_fail + rx1191_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1197_pos = $P10."pos"() + rx1191_pos = $P10."pos"() # rx pass - rx1197_cur."!cursor_pass"(rx1197_pos, "infix:sym<&&>") - rx1197_cur."!cursor_debug"("PASS ", "infix:sym<&&>", " at pos=", rx1197_pos) - .return (rx1197_cur) - rx1197_fail: -.annotate 'line', 433 - (rx1197_rep, rx1197_pos, $I10, $P10) = rx1197_cur."!mark_fail"(0) - lt rx1197_pos, -1, rx1197_done - eq rx1197_pos, -1, rx1197_fail + rx1191_cur."!cursor_pass"(rx1191_pos, "infix:sym") + rx1191_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1191_pos) + .return (rx1191_cur) + rx1191_fail: +.annotate 'line', 445 + (rx1191_rep, rx1191_pos, $I10, $P10) = rx1191_cur."!mark_fail"(0) + lt rx1191_pos, -1, rx1191_done + eq rx1191_pos, -1, rx1191_fail jump $I10 - rx1197_done: - rx1197_cur."!cursor_fail"() - rx1197_cur."!cursor_debug"("FAIL ", "infix:sym<&&>") - .return (rx1197_cur) + rx1191_done: + rx1191_cur."!cursor_fail"() + rx1191_cur."!cursor_debug"("FAIL ", "infix:sym") + .return (rx1191_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<&&>" :subid("306_1275511697.61926") :method -.annotate 'line', 433 - $P1199 = self."!PREFIX__!subrule"("O", "&&") - new $P1200, "ResizablePMCArray" - push $P1200, $P1199 - .return ($P1200) +.sub "!PREFIX__infix:sym" :subid("305_1275600007.84296") :method +.annotate 'line', 445 + $P1193 = self."!PREFIX__!subrule"("O", "ge") + new $P1194, "ResizablePMCArray" + push $P1194, $P1193 + .return ($P1194) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<||>" :subid("307_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1204_tgt - .local int rx1204_pos - .local int rx1204_off - .local int rx1204_eos - .local int rx1204_rep - .local pmc rx1204_cur - (rx1204_cur, rx1204_pos, rx1204_tgt) = self."!cursor_start"() - rx1204_cur."!cursor_debug"("START ", "infix:sym<||>") - .lex unicode:"$\x{a2}", rx1204_cur +.sub "infix:sym" :subid("306_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1198_tgt + .local int rx1198_pos + .local int rx1198_off + .local int rx1198_eos + .local int rx1198_rep + .local pmc rx1198_cur + (rx1198_cur, rx1198_pos, rx1198_tgt) = self."!cursor_start"() + rx1198_cur."!cursor_debug"("START ", "infix:sym") + .lex unicode:"$\x{a2}", rx1198_cur .local pmc match .lex "$/", match - length rx1204_eos, rx1204_tgt - gt rx1204_pos, rx1204_eos, rx1204_done - set rx1204_off, 0 - lt rx1204_pos, 2, rx1204_start - sub rx1204_off, rx1204_pos, 1 - substr rx1204_tgt, rx1204_tgt, rx1204_off - rx1204_start: + length rx1198_eos, rx1198_tgt + gt rx1198_pos, rx1198_eos, rx1198_done + set rx1198_off, 0 + lt rx1198_pos, 2, rx1198_start + sub rx1198_off, rx1198_pos, 1 + substr rx1198_tgt, rx1198_tgt, rx1198_off + rx1198_start: $I10 = self.'from'() - ne $I10, -1, rxscan1208_done - goto rxscan1208_scan - rxscan1208_loop: - ($P10) = rx1204_cur."from"() + ne $I10, -1, rxscan1202_done + goto rxscan1202_scan + rxscan1202_loop: + ($P10) = rx1198_cur."from"() inc $P10 - set rx1204_pos, $P10 - ge rx1204_pos, rx1204_eos, rxscan1208_done - rxscan1208_scan: - set_addr $I10, rxscan1208_loop - rx1204_cur."!mark_push"(0, rx1204_pos, $I10) - rxscan1208_done: -.annotate 'line', 519 + set rx1198_pos, $P10 + ge rx1198_pos, rx1198_eos, rxscan1202_done + rxscan1202_scan: + set_addr $I10, rxscan1202_loop + rx1198_cur."!mark_push"(0, rx1198_pos, $I10) + rxscan1202_done: +.annotate 'line', 524 # rx subcapture "sym" - set_addr $I10, rxcap_1209_fail - rx1204_cur."!mark_push"(0, rx1204_pos, $I10) - # rx literal "||" - add $I11, rx1204_pos, 2 - gt $I11, rx1204_eos, rx1204_fail - sub $I11, rx1204_pos, rx1204_off - substr $S10, rx1204_tgt, $I11, 2 - ne $S10, "||", rx1204_fail - add rx1204_pos, 2 - set_addr $I10, rxcap_1209_fail - ($I12, $I11) = rx1204_cur."!mark_peek"($I10) - rx1204_cur."!cursor_pos"($I11) - ($P10) = rx1204_cur."!cursor_start"() - $P10."!cursor_pass"(rx1204_pos, "") - rx1204_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1203_fail + rx1198_cur."!mark_push"(0, rx1198_pos, $I10) + # rx literal "lt" + add $I11, rx1198_pos, 2 + gt $I11, rx1198_eos, rx1198_fail + sub $I11, rx1198_pos, rx1198_off + substr $S10, rx1198_tgt, $I11, 2 + ne $S10, "lt", rx1198_fail + add rx1198_pos, 2 + set_addr $I10, rxcap_1203_fail + ($I12, $I11) = rx1198_cur."!mark_peek"($I10) + rx1198_cur."!cursor_pos"($I11) + ($P10) = rx1198_cur."!cursor_start"() + $P10."!cursor_pass"(rx1198_pos, "") + rx1198_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1209_done - rxcap_1209_fail: - goto rx1204_fail - rxcap_1209_done: + goto rxcap_1203_done + rxcap_1203_fail: + goto rx1198_fail + rxcap_1203_done: # rx subrule "O" subtype=capture negate= - rx1204_cur."!cursor_pos"(rx1204_pos) - $P10 = rx1204_cur."O"("%tight_or, :pasttype") - unless $P10, rx1204_fail - rx1204_cur."!mark_push"(0, -1, 0, $P10) + rx1198_cur."!cursor_pos"(rx1198_pos) + $P10 = rx1198_cur."O"("%relational, :pirop") + unless $P10, rx1198_fail + rx1198_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1204_pos = $P10."pos"() + rx1198_pos = $P10."pos"() # rx pass - rx1204_cur."!cursor_pass"(rx1204_pos, "infix:sym<||>") - rx1204_cur."!cursor_debug"("PASS ", "infix:sym<||>", " at pos=", rx1204_pos) - .return (rx1204_cur) - rx1204_fail: -.annotate 'line', 433 - (rx1204_rep, rx1204_pos, $I10, $P10) = rx1204_cur."!mark_fail"(0) - lt rx1204_pos, -1, rx1204_done - eq rx1204_pos, -1, rx1204_fail + rx1198_cur."!cursor_pass"(rx1198_pos, "infix:sym") + rx1198_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1198_pos) + .return (rx1198_cur) + rx1198_fail: +.annotate 'line', 445 + (rx1198_rep, rx1198_pos, $I10, $P10) = rx1198_cur."!mark_fail"(0) + lt rx1198_pos, -1, rx1198_done + eq rx1198_pos, -1, rx1198_fail jump $I10 - rx1204_done: - rx1204_cur."!cursor_fail"() - rx1204_cur."!cursor_debug"("FAIL ", "infix:sym<||>") - .return (rx1204_cur) + rx1198_done: + rx1198_cur."!cursor_fail"() + rx1198_cur."!cursor_debug"("FAIL ", "infix:sym") + .return (rx1198_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<||>" :subid("308_1275511697.61926") :method -.annotate 'line', 433 - $P1206 = self."!PREFIX__!subrule"("O", "||") - new $P1207, "ResizablePMCArray" - push $P1207, $P1206 - .return ($P1207) +.sub "!PREFIX__infix:sym" :subid("307_1275600007.84296") :method +.annotate 'line', 445 + $P1200 = self."!PREFIX__!subrule"("O", "lt") + new $P1201, "ResizablePMCArray" + push $P1201, $P1200 + .return ($P1201) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym" :subid("309_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1211_tgt - .local int rx1211_pos - .local int rx1211_off - .local int rx1211_eos - .local int rx1211_rep - .local pmc rx1211_cur - (rx1211_cur, rx1211_pos, rx1211_tgt) = self."!cursor_start"() - rx1211_cur."!cursor_debug"("START ", "infix:sym") - .lex unicode:"$\x{a2}", rx1211_cur +.sub "infix:sym" :subid("308_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1205_tgt + .local int rx1205_pos + .local int rx1205_off + .local int rx1205_eos + .local int rx1205_rep + .local pmc rx1205_cur + (rx1205_cur, rx1205_pos, rx1205_tgt) = self."!cursor_start"() + rx1205_cur."!cursor_debug"("START ", "infix:sym") + .lex unicode:"$\x{a2}", rx1205_cur .local pmc match .lex "$/", match - length rx1211_eos, rx1211_tgt - gt rx1211_pos, rx1211_eos, rx1211_done - set rx1211_off, 0 - lt rx1211_pos, 2, rx1211_start - sub rx1211_off, rx1211_pos, 1 - substr rx1211_tgt, rx1211_tgt, rx1211_off - rx1211_start: + length rx1205_eos, rx1205_tgt + gt rx1205_pos, rx1205_eos, rx1205_done + set rx1205_off, 0 + lt rx1205_pos, 2, rx1205_start + sub rx1205_off, rx1205_pos, 1 + substr rx1205_tgt, rx1205_tgt, rx1205_off + rx1205_start: $I10 = self.'from'() - ne $I10, -1, rxscan1215_done - goto rxscan1215_scan - rxscan1215_loop: - ($P10) = rx1211_cur."from"() + ne $I10, -1, rxscan1209_done + goto rxscan1209_scan + rxscan1209_loop: + ($P10) = rx1205_cur."from"() inc $P10 - set rx1211_pos, $P10 - ge rx1211_pos, rx1211_eos, rxscan1215_done - rxscan1215_scan: - set_addr $I10, rxscan1215_loop - rx1211_cur."!mark_push"(0, rx1211_pos, $I10) - rxscan1215_done: -.annotate 'line', 520 + set rx1205_pos, $P10 + ge rx1205_pos, rx1205_eos, rxscan1209_done + rxscan1209_scan: + set_addr $I10, rxscan1209_loop + rx1205_cur."!mark_push"(0, rx1205_pos, $I10) + rxscan1209_done: +.annotate 'line', 525 # rx subcapture "sym" - set_addr $I10, rxcap_1216_fail - rx1211_cur."!mark_push"(0, rx1211_pos, $I10) - # rx literal "//" - add $I11, rx1211_pos, 2 - gt $I11, rx1211_eos, rx1211_fail - sub $I11, rx1211_pos, rx1211_off - substr $S10, rx1211_tgt, $I11, 2 - ne $S10, "//", rx1211_fail - add rx1211_pos, 2 - set_addr $I10, rxcap_1216_fail - ($I12, $I11) = rx1211_cur."!mark_peek"($I10) - rx1211_cur."!cursor_pos"($I11) - ($P10) = rx1211_cur."!cursor_start"() - $P10."!cursor_pass"(rx1211_pos, "") - rx1211_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1210_fail + rx1205_cur."!mark_push"(0, rx1205_pos, $I10) + # rx literal "gt" + add $I11, rx1205_pos, 2 + gt $I11, rx1205_eos, rx1205_fail + sub $I11, rx1205_pos, rx1205_off + substr $S10, rx1205_tgt, $I11, 2 + ne $S10, "gt", rx1205_fail + add rx1205_pos, 2 + set_addr $I10, rxcap_1210_fail + ($I12, $I11) = rx1205_cur."!mark_peek"($I10) + rx1205_cur."!cursor_pos"($I11) + ($P10) = rx1205_cur."!cursor_start"() + $P10."!cursor_pass"(rx1205_pos, "") + rx1205_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1216_done - rxcap_1216_fail: - goto rx1211_fail - rxcap_1216_done: + goto rxcap_1210_done + rxcap_1210_fail: + goto rx1205_fail + rxcap_1210_done: # rx subrule "O" subtype=capture negate= - rx1211_cur."!cursor_pos"(rx1211_pos) - $P10 = rx1211_cur."O"("%tight_or, :pasttype") - unless $P10, rx1211_fail - rx1211_cur."!mark_push"(0, -1, 0, $P10) + rx1205_cur."!cursor_pos"(rx1205_pos) + $P10 = rx1205_cur."O"("%relational, :pirop") + unless $P10, rx1205_fail + rx1205_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1211_pos = $P10."pos"() + rx1205_pos = $P10."pos"() # rx pass - rx1211_cur."!cursor_pass"(rx1211_pos, "infix:sym") - rx1211_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1211_pos) - .return (rx1211_cur) - rx1211_fail: -.annotate 'line', 433 - (rx1211_rep, rx1211_pos, $I10, $P10) = rx1211_cur."!mark_fail"(0) - lt rx1211_pos, -1, rx1211_done - eq rx1211_pos, -1, rx1211_fail + rx1205_cur."!cursor_pass"(rx1205_pos, "infix:sym") + rx1205_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1205_pos) + .return (rx1205_cur) + rx1205_fail: +.annotate 'line', 445 + (rx1205_rep, rx1205_pos, $I10, $P10) = rx1205_cur."!mark_fail"(0) + lt rx1205_pos, -1, rx1205_done + eq rx1205_pos, -1, rx1205_fail jump $I10 - rx1211_done: - rx1211_cur."!cursor_fail"() - rx1211_cur."!cursor_debug"("FAIL ", "infix:sym") - .return (rx1211_cur) + rx1205_done: + rx1205_cur."!cursor_fail"() + rx1205_cur."!cursor_debug"("FAIL ", "infix:sym") + .return (rx1205_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym" :subid("310_1275511697.61926") :method -.annotate 'line', 433 - $P1213 = self."!PREFIX__!subrule"("O", "//") - new $P1214, "ResizablePMCArray" - push $P1214, $P1213 - .return ($P1214) +.sub "!PREFIX__infix:sym" :subid("309_1275600007.84296") :method +.annotate 'line', 445 + $P1207 = self."!PREFIX__!subrule"("O", "gt") + new $P1208, "ResizablePMCArray" + push $P1208, $P1207 + .return ($P1208) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym" :subid("311_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1218_tgt - .local int rx1218_pos - .local int rx1218_off - .local int rx1218_eos - .local int rx1218_rep - .local pmc rx1218_cur - (rx1218_cur, rx1218_pos, rx1218_tgt) = self."!cursor_start"() - rx1218_cur."!cursor_debug"("START ", "infix:sym") - .lex unicode:"$\x{a2}", rx1218_cur +.sub "infix:sym<=:=>" :subid("310_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1212_tgt + .local int rx1212_pos + .local int rx1212_off + .local int rx1212_eos + .local int rx1212_rep + .local pmc rx1212_cur + (rx1212_cur, rx1212_pos, rx1212_tgt) = self."!cursor_start"() + rx1212_cur."!cursor_debug"("START ", "infix:sym<=:=>") + .lex unicode:"$\x{a2}", rx1212_cur .local pmc match .lex "$/", match - length rx1218_eos, rx1218_tgt - gt rx1218_pos, rx1218_eos, rx1218_done - set rx1218_off, 0 - lt rx1218_pos, 2, rx1218_start - sub rx1218_off, rx1218_pos, 1 - substr rx1218_tgt, rx1218_tgt, rx1218_off - rx1218_start: + length rx1212_eos, rx1212_tgt + gt rx1212_pos, rx1212_eos, rx1212_done + set rx1212_off, 0 + lt rx1212_pos, 2, rx1212_start + sub rx1212_off, rx1212_pos, 1 + substr rx1212_tgt, rx1212_tgt, rx1212_off + rx1212_start: $I10 = self.'from'() - ne $I10, -1, rxscan1222_done - goto rxscan1222_scan - rxscan1222_loop: - ($P10) = rx1218_cur."from"() + ne $I10, -1, rxscan1216_done + goto rxscan1216_scan + rxscan1216_loop: + ($P10) = rx1212_cur."from"() inc $P10 - set rx1218_pos, $P10 - ge rx1218_pos, rx1218_eos, rxscan1222_done - rxscan1222_scan: - set_addr $I10, rxscan1222_loop - rx1218_cur."!mark_push"(0, rx1218_pos, $I10) - rxscan1222_done: -.annotate 'line', 523 - # rx literal "??" - add $I11, rx1218_pos, 2 - gt $I11, rx1218_eos, rx1218_fail - sub $I11, rx1218_pos, rx1218_off - substr $S10, rx1218_tgt, $I11, 2 - ne $S10, "??", rx1218_fail - add rx1218_pos, 2 -.annotate 'line', 524 - # rx subrule "ws" subtype=method negate= - rx1218_cur."!cursor_pos"(rx1218_pos) - $P10 = rx1218_cur."ws"() - unless $P10, rx1218_fail - rx1218_pos = $P10."pos"() -.annotate 'line', 525 - # rx subrule "EXPR" subtype=capture negate= - rx1218_cur."!cursor_pos"(rx1218_pos) - $P10 = rx1218_cur."EXPR"("i=") - unless $P10, rx1218_fail - rx1218_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("EXPR") - rx1218_pos = $P10."pos"() + set rx1212_pos, $P10 + ge rx1212_pos, rx1212_eos, rxscan1216_done + rxscan1216_scan: + set_addr $I10, rxscan1216_loop + rx1212_cur."!mark_push"(0, rx1212_pos, $I10) + rxscan1216_done: .annotate 'line', 526 - # rx literal "!!" - add $I11, rx1218_pos, 2 - gt $I11, rx1218_eos, rx1218_fail - sub $I11, rx1218_pos, rx1218_off - substr $S10, rx1218_tgt, $I11, 2 - ne $S10, "!!", rx1218_fail - add rx1218_pos, 2 -.annotate 'line', 527 + # rx subcapture "sym" + set_addr $I10, rxcap_1217_fail + rx1212_cur."!mark_push"(0, rx1212_pos, $I10) + # rx literal "=:=" + add $I11, rx1212_pos, 3 + gt $I11, rx1212_eos, rx1212_fail + sub $I11, rx1212_pos, rx1212_off + substr $S10, rx1212_tgt, $I11, 3 + ne $S10, "=:=", rx1212_fail + add rx1212_pos, 3 + set_addr $I10, rxcap_1217_fail + ($I12, $I11) = rx1212_cur."!mark_peek"($I10) + rx1212_cur."!cursor_pos"($I11) + ($P10) = rx1212_cur."!cursor_start"() + $P10."!cursor_pass"(rx1212_pos, "") + rx1212_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("sym") + goto rxcap_1217_done + rxcap_1217_fail: + goto rx1212_fail + rxcap_1217_done: # rx subrule "O" subtype=capture negate= - rx1218_cur."!cursor_pos"(rx1218_pos) - $P10 = rx1218_cur."O"("%conditional, :reducecheck, :pasttype") - unless $P10, rx1218_fail - rx1218_cur."!mark_push"(0, -1, 0, $P10) + rx1212_cur."!cursor_pos"(rx1212_pos) + $P10 = rx1212_cur."O"("%relational, :pirop") + unless $P10, rx1212_fail + rx1212_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1218_pos = $P10."pos"() -.annotate 'line', 522 + rx1212_pos = $P10."pos"() # rx pass - rx1218_cur."!cursor_pass"(rx1218_pos, "infix:sym") - rx1218_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1218_pos) - .return (rx1218_cur) - rx1218_fail: -.annotate 'line', 433 - (rx1218_rep, rx1218_pos, $I10, $P10) = rx1218_cur."!mark_fail"(0) - lt rx1218_pos, -1, rx1218_done - eq rx1218_pos, -1, rx1218_fail + rx1212_cur."!cursor_pass"(rx1212_pos, "infix:sym<=:=>") + rx1212_cur."!cursor_debug"("PASS ", "infix:sym<=:=>", " at pos=", rx1212_pos) + .return (rx1212_cur) + rx1212_fail: +.annotate 'line', 445 + (rx1212_rep, rx1212_pos, $I10, $P10) = rx1212_cur."!mark_fail"(0) + lt rx1212_pos, -1, rx1212_done + eq rx1212_pos, -1, rx1212_fail jump $I10 - rx1218_done: - rx1218_cur."!cursor_fail"() - rx1218_cur."!cursor_debug"("FAIL ", "infix:sym") - .return (rx1218_cur) + rx1212_done: + rx1212_cur."!cursor_fail"() + rx1212_cur."!cursor_debug"("FAIL ", "infix:sym<=:=>") + .return (rx1212_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym" :subid("312_1275511697.61926") :method -.annotate 'line', 433 - $P1220 = self."!PREFIX__!subrule"("", "??") - new $P1221, "ResizablePMCArray" - push $P1221, $P1220 - .return ($P1221) +.sub "!PREFIX__infix:sym<=:=>" :subid("311_1275600007.84296") :method +.annotate 'line', 445 + $P1214 = self."!PREFIX__!subrule"("O", "=:=") + new $P1215, "ResizablePMCArray" + push $P1215, $P1214 + .return ($P1215) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<=>" :subid("313_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1224_tgt - .local int rx1224_pos - .local int rx1224_off - .local int rx1224_eos - .local int rx1224_rep - .local pmc rx1224_cur - (rx1224_cur, rx1224_pos, rx1224_tgt) = self."!cursor_start"() - rx1224_cur."!cursor_debug"("START ", "infix:sym<=>") - .lex unicode:"$\x{a2}", rx1224_cur +.sub "infix:sym<~~>" :subid("312_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1219_tgt + .local int rx1219_pos + .local int rx1219_off + .local int rx1219_eos + .local int rx1219_rep + .local pmc rx1219_cur + (rx1219_cur, rx1219_pos, rx1219_tgt) = self."!cursor_start"() + rx1219_cur."!cursor_debug"("START ", "infix:sym<~~>") + .lex unicode:"$\x{a2}", rx1219_cur .local pmc match .lex "$/", match - length rx1224_eos, rx1224_tgt - gt rx1224_pos, rx1224_eos, rx1224_done - set rx1224_off, 0 - lt rx1224_pos, 2, rx1224_start - sub rx1224_off, rx1224_pos, 1 - substr rx1224_tgt, rx1224_tgt, rx1224_off - rx1224_start: + length rx1219_eos, rx1219_tgt + gt rx1219_pos, rx1219_eos, rx1219_done + set rx1219_off, 0 + lt rx1219_pos, 2, rx1219_start + sub rx1219_off, rx1219_pos, 1 + substr rx1219_tgt, rx1219_tgt, rx1219_off + rx1219_start: $I10 = self.'from'() - ne $I10, -1, rxscan1228_done - goto rxscan1228_scan - rxscan1228_loop: - ($P10) = rx1224_cur."from"() + ne $I10, -1, rxscan1223_done + goto rxscan1223_scan + rxscan1223_loop: + ($P10) = rx1219_cur."from"() inc $P10 - set rx1224_pos, $P10 - ge rx1224_pos, rx1224_eos, rxscan1228_done - rxscan1228_scan: - set_addr $I10, rxscan1228_loop - rx1224_cur."!mark_push"(0, rx1224_pos, $I10) - rxscan1228_done: -.annotate 'line', 531 + set rx1219_pos, $P10 + ge rx1219_pos, rx1219_eos, rxscan1223_done + rxscan1223_scan: + set_addr $I10, rxscan1223_loop + rx1219_cur."!mark_push"(0, rx1219_pos, $I10) + rxscan1223_done: +.annotate 'line', 527 # rx subcapture "sym" - set_addr $I10, rxcap_1229_fail - rx1224_cur."!mark_push"(0, rx1224_pos, $I10) - # rx literal "=" - add $I11, rx1224_pos, 1 - gt $I11, rx1224_eos, rx1224_fail - sub $I11, rx1224_pos, rx1224_off - substr $S10, rx1224_tgt, $I11, 1 - ne $S10, "=", rx1224_fail - add rx1224_pos, 1 - set_addr $I10, rxcap_1229_fail - ($I12, $I11) = rx1224_cur."!mark_peek"($I10) - rx1224_cur."!cursor_pos"($I11) - ($P10) = rx1224_cur."!cursor_start"() - $P10."!cursor_pass"(rx1224_pos, "") - rx1224_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1224_fail + rx1219_cur."!mark_push"(0, rx1219_pos, $I10) + # rx literal "~~" + add $I11, rx1219_pos, 2 + gt $I11, rx1219_eos, rx1219_fail + sub $I11, rx1219_pos, rx1219_off + substr $S10, rx1219_tgt, $I11, 2 + ne $S10, "~~", rx1219_fail + add rx1219_pos, 2 + set_addr $I10, rxcap_1224_fail + ($I12, $I11) = rx1219_cur."!mark_peek"($I10) + rx1219_cur."!cursor_pos"($I11) + ($P10) = rx1219_cur."!cursor_start"() + $P10."!cursor_pass"(rx1219_pos, "") + rx1219_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1229_done - rxcap_1229_fail: - goto rx1224_fail - rxcap_1229_done: - # rx subrule "panic" subtype=method negate= - rx1224_cur."!cursor_pos"(rx1224_pos) - $P10 = rx1224_cur."panic"("Assignment (\"=\") not supported in NQP, use \":=\" instead") - unless $P10, rx1224_fail - rx1224_pos = $P10."pos"() -.annotate 'line', 530 + goto rxcap_1224_done + rxcap_1224_fail: + goto rx1219_fail + rxcap_1224_done: + # rx subrule "O" subtype=capture negate= + rx1219_cur."!cursor_pos"(rx1219_pos) + $P10 = rx1219_cur."O"("%relational, :reducecheck") + unless $P10, rx1219_fail + rx1219_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("O") + rx1219_pos = $P10."pos"() # rx pass - rx1224_cur."!cursor_pass"(rx1224_pos, "infix:sym<=>") - rx1224_cur."!cursor_debug"("PASS ", "infix:sym<=>", " at pos=", rx1224_pos) - .return (rx1224_cur) - rx1224_fail: -.annotate 'line', 433 - (rx1224_rep, rx1224_pos, $I10, $P10) = rx1224_cur."!mark_fail"(0) - lt rx1224_pos, -1, rx1224_done - eq rx1224_pos, -1, rx1224_fail + rx1219_cur."!cursor_pass"(rx1219_pos, "infix:sym<~~>") + rx1219_cur."!cursor_debug"("PASS ", "infix:sym<~~>", " at pos=", rx1219_pos) + .return (rx1219_cur) + rx1219_fail: +.annotate 'line', 445 + (rx1219_rep, rx1219_pos, $I10, $P10) = rx1219_cur."!mark_fail"(0) + lt rx1219_pos, -1, rx1219_done + eq rx1219_pos, -1, rx1219_fail jump $I10 - rx1224_done: - rx1224_cur."!cursor_fail"() - rx1224_cur."!cursor_debug"("FAIL ", "infix:sym<=>") - .return (rx1224_cur) + rx1219_done: + rx1219_cur."!cursor_fail"() + rx1219_cur."!cursor_debug"("FAIL ", "infix:sym<~~>") + .return (rx1219_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<=>" :subid("314_1275511697.61926") :method -.annotate 'line', 433 - $P1226 = self."!PREFIX__!subrule"("", "=") - new $P1227, "ResizablePMCArray" - push $P1227, $P1226 - .return ($P1227) +.sub "!PREFIX__infix:sym<~~>" :subid("313_1275600007.84296") :method +.annotate 'line', 445 + $P1221 = self."!PREFIX__!subrule"("O", "~~") + new $P1222, "ResizablePMCArray" + push $P1222, $P1221 + .return ($P1222) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<:=>" :subid("315_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1231_tgt - .local int rx1231_pos - .local int rx1231_off - .local int rx1231_eos - .local int rx1231_rep - .local pmc rx1231_cur - (rx1231_cur, rx1231_pos, rx1231_tgt) = self."!cursor_start"() - rx1231_cur."!cursor_debug"("START ", "infix:sym<:=>") - .lex unicode:"$\x{a2}", rx1231_cur +.sub "infix:sym<&&>" :subid("314_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1226_tgt + .local int rx1226_pos + .local int rx1226_off + .local int rx1226_eos + .local int rx1226_rep + .local pmc rx1226_cur + (rx1226_cur, rx1226_pos, rx1226_tgt) = self."!cursor_start"() + rx1226_cur."!cursor_debug"("START ", "infix:sym<&&>") + .lex unicode:"$\x{a2}", rx1226_cur .local pmc match .lex "$/", match - length rx1231_eos, rx1231_tgt - gt rx1231_pos, rx1231_eos, rx1231_done - set rx1231_off, 0 - lt rx1231_pos, 2, rx1231_start - sub rx1231_off, rx1231_pos, 1 - substr rx1231_tgt, rx1231_tgt, rx1231_off - rx1231_start: + length rx1226_eos, rx1226_tgt + gt rx1226_pos, rx1226_eos, rx1226_done + set rx1226_off, 0 + lt rx1226_pos, 2, rx1226_start + sub rx1226_off, rx1226_pos, 1 + substr rx1226_tgt, rx1226_tgt, rx1226_off + rx1226_start: $I10 = self.'from'() - ne $I10, -1, rxscan1235_done - goto rxscan1235_scan - rxscan1235_loop: - ($P10) = rx1231_cur."from"() + ne $I10, -1, rxscan1230_done + goto rxscan1230_scan + rxscan1230_loop: + ($P10) = rx1226_cur."from"() inc $P10 - set rx1231_pos, $P10 - ge rx1231_pos, rx1231_eos, rxscan1235_done - rxscan1235_scan: - set_addr $I10, rxscan1235_loop - rx1231_cur."!mark_push"(0, rx1231_pos, $I10) - rxscan1235_done: -.annotate 'line', 533 + set rx1226_pos, $P10 + ge rx1226_pos, rx1226_eos, rxscan1230_done + rxscan1230_scan: + set_addr $I10, rxscan1230_loop + rx1226_cur."!mark_push"(0, rx1226_pos, $I10) + rxscan1230_done: +.annotate 'line', 529 # rx subcapture "sym" - set_addr $I10, rxcap_1236_fail - rx1231_cur."!mark_push"(0, rx1231_pos, $I10) - # rx literal ":=" - add $I11, rx1231_pos, 2 - gt $I11, rx1231_eos, rx1231_fail - sub $I11, rx1231_pos, rx1231_off - substr $S10, rx1231_tgt, $I11, 2 - ne $S10, ":=", rx1231_fail - add rx1231_pos, 2 - set_addr $I10, rxcap_1236_fail - ($I12, $I11) = rx1231_cur."!mark_peek"($I10) - rx1231_cur."!cursor_pos"($I11) - ($P10) = rx1231_cur."!cursor_start"() - $P10."!cursor_pass"(rx1231_pos, "") - rx1231_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1231_fail + rx1226_cur."!mark_push"(0, rx1226_pos, $I10) + # rx literal "&&" + add $I11, rx1226_pos, 2 + gt $I11, rx1226_eos, rx1226_fail + sub $I11, rx1226_pos, rx1226_off + substr $S10, rx1226_tgt, $I11, 2 + ne $S10, "&&", rx1226_fail + add rx1226_pos, 2 + set_addr $I10, rxcap_1231_fail + ($I12, $I11) = rx1226_cur."!mark_peek"($I10) + rx1226_cur."!cursor_pos"($I11) + ($P10) = rx1226_cur."!cursor_start"() + $P10."!cursor_pass"(rx1226_pos, "") + rx1226_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1236_done - rxcap_1236_fail: - goto rx1231_fail - rxcap_1236_done: + goto rxcap_1231_done + rxcap_1231_fail: + goto rx1226_fail + rxcap_1231_done: # rx subrule "O" subtype=capture negate= - rx1231_cur."!cursor_pos"(rx1231_pos) - $P10 = rx1231_cur."O"("%assignment, :pasttype") - unless $P10, rx1231_fail - rx1231_cur."!mark_push"(0, -1, 0, $P10) + rx1226_cur."!cursor_pos"(rx1226_pos) + $P10 = rx1226_cur."O"("%tight_and, :pasttype") + unless $P10, rx1226_fail + rx1226_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1231_pos = $P10."pos"() + rx1226_pos = $P10."pos"() # rx pass - rx1231_cur."!cursor_pass"(rx1231_pos, "infix:sym<:=>") - rx1231_cur."!cursor_debug"("PASS ", "infix:sym<:=>", " at pos=", rx1231_pos) - .return (rx1231_cur) - rx1231_fail: -.annotate 'line', 433 - (rx1231_rep, rx1231_pos, $I10, $P10) = rx1231_cur."!mark_fail"(0) - lt rx1231_pos, -1, rx1231_done - eq rx1231_pos, -1, rx1231_fail + rx1226_cur."!cursor_pass"(rx1226_pos, "infix:sym<&&>") + rx1226_cur."!cursor_debug"("PASS ", "infix:sym<&&>", " at pos=", rx1226_pos) + .return (rx1226_cur) + rx1226_fail: +.annotate 'line', 445 + (rx1226_rep, rx1226_pos, $I10, $P10) = rx1226_cur."!mark_fail"(0) + lt rx1226_pos, -1, rx1226_done + eq rx1226_pos, -1, rx1226_fail jump $I10 - rx1231_done: - rx1231_cur."!cursor_fail"() - rx1231_cur."!cursor_debug"("FAIL ", "infix:sym<:=>") - .return (rx1231_cur) + rx1226_done: + rx1226_cur."!cursor_fail"() + rx1226_cur."!cursor_debug"("FAIL ", "infix:sym<&&>") + .return (rx1226_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<:=>" :subid("316_1275511697.61926") :method -.annotate 'line', 433 - $P1233 = self."!PREFIX__!subrule"("O", ":=") - new $P1234, "ResizablePMCArray" - push $P1234, $P1233 - .return ($P1234) +.sub "!PREFIX__infix:sym<&&>" :subid("315_1275600007.84296") :method +.annotate 'line', 445 + $P1228 = self."!PREFIX__!subrule"("O", "&&") + new $P1229, "ResizablePMCArray" + push $P1229, $P1228 + .return ($P1229) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<::=>" :subid("317_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1238_tgt - .local int rx1238_pos - .local int rx1238_off - .local int rx1238_eos - .local int rx1238_rep - .local pmc rx1238_cur - (rx1238_cur, rx1238_pos, rx1238_tgt) = self."!cursor_start"() - rx1238_cur."!cursor_debug"("START ", "infix:sym<::=>") - .lex unicode:"$\x{a2}", rx1238_cur +.sub "infix:sym<||>" :subid("316_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1233_tgt + .local int rx1233_pos + .local int rx1233_off + .local int rx1233_eos + .local int rx1233_rep + .local pmc rx1233_cur + (rx1233_cur, rx1233_pos, rx1233_tgt) = self."!cursor_start"() + rx1233_cur."!cursor_debug"("START ", "infix:sym<||>") + .lex unicode:"$\x{a2}", rx1233_cur .local pmc match .lex "$/", match - length rx1238_eos, rx1238_tgt - gt rx1238_pos, rx1238_eos, rx1238_done - set rx1238_off, 0 - lt rx1238_pos, 2, rx1238_start - sub rx1238_off, rx1238_pos, 1 - substr rx1238_tgt, rx1238_tgt, rx1238_off - rx1238_start: + length rx1233_eos, rx1233_tgt + gt rx1233_pos, rx1233_eos, rx1233_done + set rx1233_off, 0 + lt rx1233_pos, 2, rx1233_start + sub rx1233_off, rx1233_pos, 1 + substr rx1233_tgt, rx1233_tgt, rx1233_off + rx1233_start: $I10 = self.'from'() - ne $I10, -1, rxscan1242_done - goto rxscan1242_scan - rxscan1242_loop: - ($P10) = rx1238_cur."from"() + ne $I10, -1, rxscan1237_done + goto rxscan1237_scan + rxscan1237_loop: + ($P10) = rx1233_cur."from"() inc $P10 - set rx1238_pos, $P10 - ge rx1238_pos, rx1238_eos, rxscan1242_done - rxscan1242_scan: - set_addr $I10, rxscan1242_loop - rx1238_cur."!mark_push"(0, rx1238_pos, $I10) - rxscan1242_done: -.annotate 'line', 534 + set rx1233_pos, $P10 + ge rx1233_pos, rx1233_eos, rxscan1237_done + rxscan1237_scan: + set_addr $I10, rxscan1237_loop + rx1233_cur."!mark_push"(0, rx1233_pos, $I10) + rxscan1237_done: +.annotate 'line', 531 # rx subcapture "sym" - set_addr $I10, rxcap_1243_fail - rx1238_cur."!mark_push"(0, rx1238_pos, $I10) - # rx literal "::=" - add $I11, rx1238_pos, 3 - gt $I11, rx1238_eos, rx1238_fail - sub $I11, rx1238_pos, rx1238_off - substr $S10, rx1238_tgt, $I11, 3 - ne $S10, "::=", rx1238_fail - add rx1238_pos, 3 - set_addr $I10, rxcap_1243_fail - ($I12, $I11) = rx1238_cur."!mark_peek"($I10) - rx1238_cur."!cursor_pos"($I11) - ($P10) = rx1238_cur."!cursor_start"() - $P10."!cursor_pass"(rx1238_pos, "") - rx1238_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1238_fail + rx1233_cur."!mark_push"(0, rx1233_pos, $I10) + # rx literal "||" + add $I11, rx1233_pos, 2 + gt $I11, rx1233_eos, rx1233_fail + sub $I11, rx1233_pos, rx1233_off + substr $S10, rx1233_tgt, $I11, 2 + ne $S10, "||", rx1233_fail + add rx1233_pos, 2 + set_addr $I10, rxcap_1238_fail + ($I12, $I11) = rx1233_cur."!mark_peek"($I10) + rx1233_cur."!cursor_pos"($I11) + ($P10) = rx1233_cur."!cursor_start"() + $P10."!cursor_pass"(rx1233_pos, "") + rx1233_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1243_done - rxcap_1243_fail: - goto rx1238_fail - rxcap_1243_done: + goto rxcap_1238_done + rxcap_1238_fail: + goto rx1233_fail + rxcap_1238_done: # rx subrule "O" subtype=capture negate= - rx1238_cur."!cursor_pos"(rx1238_pos) - $P10 = rx1238_cur."O"("%assignment, :pasttype") - unless $P10, rx1238_fail - rx1238_cur."!mark_push"(0, -1, 0, $P10) + rx1233_cur."!cursor_pos"(rx1233_pos) + $P10 = rx1233_cur."O"("%tight_or, :pasttype") + unless $P10, rx1233_fail + rx1233_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1238_pos = $P10."pos"() + rx1233_pos = $P10."pos"() # rx pass - rx1238_cur."!cursor_pass"(rx1238_pos, "infix:sym<::=>") - rx1238_cur."!cursor_debug"("PASS ", "infix:sym<::=>", " at pos=", rx1238_pos) - .return (rx1238_cur) - rx1238_fail: -.annotate 'line', 433 - (rx1238_rep, rx1238_pos, $I10, $P10) = rx1238_cur."!mark_fail"(0) - lt rx1238_pos, -1, rx1238_done - eq rx1238_pos, -1, rx1238_fail + rx1233_cur."!cursor_pass"(rx1233_pos, "infix:sym<||>") + rx1233_cur."!cursor_debug"("PASS ", "infix:sym<||>", " at pos=", rx1233_pos) + .return (rx1233_cur) + rx1233_fail: +.annotate 'line', 445 + (rx1233_rep, rx1233_pos, $I10, $P10) = rx1233_cur."!mark_fail"(0) + lt rx1233_pos, -1, rx1233_done + eq rx1233_pos, -1, rx1233_fail jump $I10 - rx1238_done: - rx1238_cur."!cursor_fail"() - rx1238_cur."!cursor_debug"("FAIL ", "infix:sym<::=>") - .return (rx1238_cur) + rx1233_done: + rx1233_cur."!cursor_fail"() + rx1233_cur."!cursor_debug"("FAIL ", "infix:sym<||>") + .return (rx1233_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<::=>" :subid("318_1275511697.61926") :method -.annotate 'line', 433 - $P1240 = self."!PREFIX__!subrule"("O", "::=") - new $P1241, "ResizablePMCArray" - push $P1241, $P1240 - .return ($P1241) +.sub "!PREFIX__infix:sym<||>" :subid("317_1275600007.84296") :method +.annotate 'line', 445 + $P1235 = self."!PREFIX__!subrule"("O", "||") + new $P1236, "ResizablePMCArray" + push $P1236, $P1235 + .return ($P1236) .end .namespace ["NQP";"Grammar"] -.sub "infix:sym<,>" :subid("319_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1245_tgt - .local int rx1245_pos - .local int rx1245_off - .local int rx1245_eos - .local int rx1245_rep - .local pmc rx1245_cur - (rx1245_cur, rx1245_pos, rx1245_tgt) = self."!cursor_start"() - rx1245_cur."!cursor_debug"("START ", "infix:sym<,>") - .lex unicode:"$\x{a2}", rx1245_cur +.sub "infix:sym" :subid("318_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1240_tgt + .local int rx1240_pos + .local int rx1240_off + .local int rx1240_eos + .local int rx1240_rep + .local pmc rx1240_cur + (rx1240_cur, rx1240_pos, rx1240_tgt) = self."!cursor_start"() + rx1240_cur."!cursor_debug"("START ", "infix:sym") + .lex unicode:"$\x{a2}", rx1240_cur .local pmc match .lex "$/", match - length rx1245_eos, rx1245_tgt - gt rx1245_pos, rx1245_eos, rx1245_done - set rx1245_off, 0 - lt rx1245_pos, 2, rx1245_start - sub rx1245_off, rx1245_pos, 1 - substr rx1245_tgt, rx1245_tgt, rx1245_off - rx1245_start: + length rx1240_eos, rx1240_tgt + gt rx1240_pos, rx1240_eos, rx1240_done + set rx1240_off, 0 + lt rx1240_pos, 2, rx1240_start + sub rx1240_off, rx1240_pos, 1 + substr rx1240_tgt, rx1240_tgt, rx1240_off + rx1240_start: $I10 = self.'from'() - ne $I10, -1, rxscan1249_done - goto rxscan1249_scan - rxscan1249_loop: - ($P10) = rx1245_cur."from"() + ne $I10, -1, rxscan1244_done + goto rxscan1244_scan + rxscan1244_loop: + ($P10) = rx1240_cur."from"() inc $P10 - set rx1245_pos, $P10 - ge rx1245_pos, rx1245_eos, rxscan1249_done - rxscan1249_scan: - set_addr $I10, rxscan1249_loop - rx1245_cur."!mark_push"(0, rx1245_pos, $I10) - rxscan1249_done: -.annotate 'line', 536 + set rx1240_pos, $P10 + ge rx1240_pos, rx1240_eos, rxscan1244_done + rxscan1244_scan: + set_addr $I10, rxscan1244_loop + rx1240_cur."!mark_push"(0, rx1240_pos, $I10) + rxscan1244_done: +.annotate 'line', 532 # rx subcapture "sym" - set_addr $I10, rxcap_1250_fail - rx1245_cur."!mark_push"(0, rx1245_pos, $I10) - # rx literal "," - add $I11, rx1245_pos, 1 - gt $I11, rx1245_eos, rx1245_fail - sub $I11, rx1245_pos, rx1245_off - substr $S10, rx1245_tgt, $I11, 1 - ne $S10, ",", rx1245_fail - add rx1245_pos, 1 - set_addr $I10, rxcap_1250_fail - ($I12, $I11) = rx1245_cur."!mark_peek"($I10) - rx1245_cur."!cursor_pos"($I11) - ($P10) = rx1245_cur."!cursor_start"() - $P10."!cursor_pass"(rx1245_pos, "") - rx1245_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1245_fail + rx1240_cur."!mark_push"(0, rx1240_pos, $I10) + # rx literal "//" + add $I11, rx1240_pos, 2 + gt $I11, rx1240_eos, rx1240_fail + sub $I11, rx1240_pos, rx1240_off + substr $S10, rx1240_tgt, $I11, 2 + ne $S10, "//", rx1240_fail + add rx1240_pos, 2 + set_addr $I10, rxcap_1245_fail + ($I12, $I11) = rx1240_cur."!mark_peek"($I10) + rx1240_cur."!cursor_pos"($I11) + ($P10) = rx1240_cur."!cursor_start"() + $P10."!cursor_pass"(rx1240_pos, "") + rx1240_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1250_done - rxcap_1250_fail: - goto rx1245_fail - rxcap_1250_done: + goto rxcap_1245_done + rxcap_1245_fail: + goto rx1240_fail + rxcap_1245_done: # rx subrule "O" subtype=capture negate= - rx1245_cur."!cursor_pos"(rx1245_pos) - $P10 = rx1245_cur."O"("%comma, :pasttype") - unless $P10, rx1245_fail - rx1245_cur."!mark_push"(0, -1, 0, $P10) + rx1240_cur."!cursor_pos"(rx1240_pos) + $P10 = rx1240_cur."O"("%tight_or, :pasttype") + unless $P10, rx1240_fail + rx1240_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1245_pos = $P10."pos"() + rx1240_pos = $P10."pos"() # rx pass - rx1245_cur."!cursor_pass"(rx1245_pos, "infix:sym<,>") - rx1245_cur."!cursor_debug"("PASS ", "infix:sym<,>", " at pos=", rx1245_pos) - .return (rx1245_cur) - rx1245_fail: -.annotate 'line', 433 - (rx1245_rep, rx1245_pos, $I10, $P10) = rx1245_cur."!mark_fail"(0) - lt rx1245_pos, -1, rx1245_done - eq rx1245_pos, -1, rx1245_fail + rx1240_cur."!cursor_pass"(rx1240_pos, "infix:sym") + rx1240_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1240_pos) + .return (rx1240_cur) + rx1240_fail: +.annotate 'line', 445 + (rx1240_rep, rx1240_pos, $I10, $P10) = rx1240_cur."!mark_fail"(0) + lt rx1240_pos, -1, rx1240_done + eq rx1240_pos, -1, rx1240_fail jump $I10 - rx1245_done: - rx1245_cur."!cursor_fail"() - rx1245_cur."!cursor_debug"("FAIL ", "infix:sym<,>") - .return (rx1245_cur) + rx1240_done: + rx1240_cur."!cursor_fail"() + rx1240_cur."!cursor_debug"("FAIL ", "infix:sym") + .return (rx1240_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__infix:sym<,>" :subid("320_1275511697.61926") :method -.annotate 'line', 433 - $P1247 = self."!PREFIX__!subrule"("O", ",") - new $P1248, "ResizablePMCArray" - push $P1248, $P1247 - .return ($P1248) +.sub "!PREFIX__infix:sym" :subid("319_1275600007.84296") :method +.annotate 'line', 445 + $P1242 = self."!PREFIX__!subrule"("O", "//") + new $P1243, "ResizablePMCArray" + push $P1243, $P1242 + .return ($P1243) .end .namespace ["NQP";"Grammar"] -.sub "prefix:sym" :subid("321_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1252_tgt - .local int rx1252_pos - .local int rx1252_off - .local int rx1252_eos - .local int rx1252_rep - .local pmc rx1252_cur - (rx1252_cur, rx1252_pos, rx1252_tgt) = self."!cursor_start"() - rx1252_cur."!cursor_debug"("START ", "prefix:sym") - .lex unicode:"$\x{a2}", rx1252_cur +.sub "infix:sym" :subid("320_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1247_tgt + .local int rx1247_pos + .local int rx1247_off + .local int rx1247_eos + .local int rx1247_rep + .local pmc rx1247_cur + (rx1247_cur, rx1247_pos, rx1247_tgt) = self."!cursor_start"() + rx1247_cur."!cursor_debug"("START ", "infix:sym") + .lex unicode:"$\x{a2}", rx1247_cur .local pmc match .lex "$/", match - length rx1252_eos, rx1252_tgt - gt rx1252_pos, rx1252_eos, rx1252_done - set rx1252_off, 0 - lt rx1252_pos, 2, rx1252_start - sub rx1252_off, rx1252_pos, 1 - substr rx1252_tgt, rx1252_tgt, rx1252_off - rx1252_start: + length rx1247_eos, rx1247_tgt + gt rx1247_pos, rx1247_eos, rx1247_done + set rx1247_off, 0 + lt rx1247_pos, 2, rx1247_start + sub rx1247_off, rx1247_pos, 1 + substr rx1247_tgt, rx1247_tgt, rx1247_off + rx1247_start: $I10 = self.'from'() - ne $I10, -1, rxscan1255_done - goto rxscan1255_scan - rxscan1255_loop: - ($P10) = rx1252_cur."from"() + ne $I10, -1, rxscan1251_done + goto rxscan1251_scan + rxscan1251_loop: + ($P10) = rx1247_cur."from"() inc $P10 - set rx1252_pos, $P10 - ge rx1252_pos, rx1252_eos, rxscan1255_done - rxscan1255_scan: - set_addr $I10, rxscan1255_loop - rx1252_cur."!mark_push"(0, rx1252_pos, $I10) - rxscan1255_done: + set rx1247_pos, $P10 + ge rx1247_pos, rx1247_eos, rxscan1251_done + rxscan1251_scan: + set_addr $I10, rxscan1251_loop + rx1247_cur."!mark_push"(0, rx1247_pos, $I10) + rxscan1251_done: +.annotate 'line', 535 + # rx literal "??" + add $I11, rx1247_pos, 2 + gt $I11, rx1247_eos, rx1247_fail + sub $I11, rx1247_pos, rx1247_off + substr $S10, rx1247_tgt, $I11, 2 + ne $S10, "??", rx1247_fail + add rx1247_pos, 2 +.annotate 'line', 536 + # rx subrule "ws" subtype=method negate= + rx1247_cur."!cursor_pos"(rx1247_pos) + $P10 = rx1247_cur."ws"() + unless $P10, rx1247_fail + rx1247_pos = $P10."pos"() +.annotate 'line', 537 + # rx subrule "EXPR" subtype=capture negate= + rx1247_cur."!cursor_pos"(rx1247_pos) + $P10 = rx1247_cur."EXPR"("i=") + unless $P10, rx1247_fail + rx1247_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("EXPR") + rx1247_pos = $P10."pos"() .annotate 'line', 538 - # rx subcapture "sym" - set_addr $I10, rxcap_1256_fail - rx1252_cur."!mark_push"(0, rx1252_pos, $I10) - # rx literal "return" - add $I11, rx1252_pos, 6 - gt $I11, rx1252_eos, rx1252_fail - sub $I11, rx1252_pos, rx1252_off - substr $S10, rx1252_tgt, $I11, 6 - ne $S10, "return", rx1252_fail - add rx1252_pos, 6 - set_addr $I10, rxcap_1256_fail - ($I12, $I11) = rx1252_cur."!mark_peek"($I10) - rx1252_cur."!cursor_pos"($I11) - ($P10) = rx1252_cur."!cursor_start"() - $P10."!cursor_pass"(rx1252_pos, "") - rx1252_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("sym") - goto rxcap_1256_done - rxcap_1256_fail: - goto rx1252_fail - rxcap_1256_done: - # rx charclass s - ge rx1252_pos, rx1252_eos, rx1252_fail - sub $I10, rx1252_pos, rx1252_off - is_cclass $I11, 32, rx1252_tgt, $I10 - unless $I11, rx1252_fail - inc rx1252_pos + # rx literal "!!" + add $I11, rx1247_pos, 2 + gt $I11, rx1247_eos, rx1247_fail + sub $I11, rx1247_pos, rx1247_off + substr $S10, rx1247_tgt, $I11, 2 + ne $S10, "!!", rx1247_fail + add rx1247_pos, 2 +.annotate 'line', 539 # rx subrule "O" subtype=capture negate= - rx1252_cur."!cursor_pos"(rx1252_pos) - $P10 = rx1252_cur."O"("%list_prefix, :pasttype") - unless $P10, rx1252_fail - rx1252_cur."!mark_push"(0, -1, 0, $P10) + rx1247_cur."!cursor_pos"(rx1247_pos) + $P10 = rx1247_cur."O"("%conditional, :reducecheck, :pasttype") + unless $P10, rx1247_fail + rx1247_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("O") - rx1252_pos = $P10."pos"() + rx1247_pos = $P10."pos"() +.annotate 'line', 534 # rx pass - rx1252_cur."!cursor_pass"(rx1252_pos, "prefix:sym") - rx1252_cur."!cursor_debug"("PASS ", "prefix:sym", " at pos=", rx1252_pos) - .return (rx1252_cur) - rx1252_fail: -.annotate 'line', 433 - (rx1252_rep, rx1252_pos, $I10, $P10) = rx1252_cur."!mark_fail"(0) - lt rx1252_pos, -1, rx1252_done - eq rx1252_pos, -1, rx1252_fail + rx1247_cur."!cursor_pass"(rx1247_pos, "infix:sym") + rx1247_cur."!cursor_debug"("PASS ", "infix:sym", " at pos=", rx1247_pos) + .return (rx1247_cur) + rx1247_fail: +.annotate 'line', 445 + (rx1247_rep, rx1247_pos, $I10, $P10) = rx1247_cur."!mark_fail"(0) + lt rx1247_pos, -1, rx1247_done + eq rx1247_pos, -1, rx1247_fail jump $I10 - rx1252_done: - rx1252_cur."!cursor_fail"() - rx1252_cur."!cursor_debug"("FAIL ", "prefix:sym") - .return (rx1252_cur) + rx1247_done: + rx1247_cur."!cursor_fail"() + rx1247_cur."!cursor_debug"("FAIL ", "infix:sym") + .return (rx1247_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__prefix:sym" :subid("322_1275511697.61926") :method -.annotate 'line', 433 - new $P1254, "ResizablePMCArray" - push $P1254, "return" - .return ($P1254) +.sub "!PREFIX__infix:sym" :subid("321_1275600007.84296") :method +.annotate 'line', 445 + $P1249 = self."!PREFIX__!subrule"("", "??") + new $P1250, "ResizablePMCArray" + push $P1250, $P1249 + .return ($P1250) .end .namespace ["NQP";"Grammar"] -.sub "prefix:sym" :subid("323_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1258_tgt - .local int rx1258_pos - .local int rx1258_off - .local int rx1258_eos - .local int rx1258_rep - .local pmc rx1258_cur - (rx1258_cur, rx1258_pos, rx1258_tgt) = self."!cursor_start"() - rx1258_cur."!cursor_debug"("START ", "prefix:sym") - .lex unicode:"$\x{a2}", rx1258_cur +.sub "infix:sym<=>" :subid("322_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1253_tgt + .local int rx1253_pos + .local int rx1253_off + .local int rx1253_eos + .local int rx1253_rep + .local pmc rx1253_cur + (rx1253_cur, rx1253_pos, rx1253_tgt) = self."!cursor_start"() + rx1253_cur."!cursor_debug"("START ", "infix:sym<=>") + .lex unicode:"$\x{a2}", rx1253_cur .local pmc match .lex "$/", match - length rx1258_eos, rx1258_tgt - gt rx1258_pos, rx1258_eos, rx1258_done - set rx1258_off, 0 - lt rx1258_pos, 2, rx1258_start - sub rx1258_off, rx1258_pos, 1 - substr rx1258_tgt, rx1258_tgt, rx1258_off - rx1258_start: + length rx1253_eos, rx1253_tgt + gt rx1253_pos, rx1253_eos, rx1253_done + set rx1253_off, 0 + lt rx1253_pos, 2, rx1253_start + sub rx1253_off, rx1253_pos, 1 + substr rx1253_tgt, rx1253_tgt, rx1253_off + rx1253_start: $I10 = self.'from'() - ne $I10, -1, rxscan1261_done - goto rxscan1261_scan - rxscan1261_loop: - ($P10) = rx1258_cur."from"() + ne $I10, -1, rxscan1257_done + goto rxscan1257_scan + rxscan1257_loop: + ($P10) = rx1253_cur."from"() inc $P10 - set rx1258_pos, $P10 - ge rx1258_pos, rx1258_eos, rxscan1261_done - rxscan1261_scan: - set_addr $I10, rxscan1261_loop - rx1258_cur."!mark_push"(0, rx1258_pos, $I10) - rxscan1261_done: -.annotate 'line', 539 + set rx1253_pos, $P10 + ge rx1253_pos, rx1253_eos, rxscan1257_done + rxscan1257_scan: + set_addr $I10, rxscan1257_loop + rx1253_cur."!mark_push"(0, rx1253_pos, $I10) + rxscan1257_done: +.annotate 'line', 543 # rx subcapture "sym" - set_addr $I10, rxcap_1262_fail - rx1258_cur."!mark_push"(0, rx1258_pos, $I10) - # rx literal "make" - add $I11, rx1258_pos, 4 - gt $I11, rx1258_eos, rx1258_fail - sub $I11, rx1258_pos, rx1258_off - substr $S10, rx1258_tgt, $I11, 4 - ne $S10, "make", rx1258_fail - add rx1258_pos, 4 - set_addr $I10, rxcap_1262_fail - ($I12, $I11) = rx1258_cur."!mark_peek"($I10) - rx1258_cur."!cursor_pos"($I11) - ($P10) = rx1258_cur."!cursor_start"() - $P10."!cursor_pass"(rx1258_pos, "") - rx1258_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1258_fail + rx1253_cur."!mark_push"(0, rx1253_pos, $I10) + # rx literal "=" + add $I11, rx1253_pos, 1 + gt $I11, rx1253_eos, rx1253_fail + sub $I11, rx1253_pos, rx1253_off + substr $S10, rx1253_tgt, $I11, 1 + ne $S10, "=", rx1253_fail + add rx1253_pos, 1 + set_addr $I10, rxcap_1258_fail + ($I12, $I11) = rx1253_cur."!mark_peek"($I10) + rx1253_cur."!cursor_pos"($I11) + ($P10) = rx1253_cur."!cursor_start"() + $P10."!cursor_pass"(rx1253_pos, "") + rx1253_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1262_done - rxcap_1262_fail: - goto rx1258_fail - rxcap_1262_done: - # rx charclass s - ge rx1258_pos, rx1258_eos, rx1258_fail - sub $I10, rx1258_pos, rx1258_off - is_cclass $I11, 32, rx1258_tgt, $I10 - unless $I11, rx1258_fail - inc rx1258_pos - # rx subrule "O" subtype=capture negate= - rx1258_cur."!cursor_pos"(rx1258_pos) - $P10 = rx1258_cur."O"("%list_prefix") - unless $P10, rx1258_fail - rx1258_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("O") - rx1258_pos = $P10."pos"() + goto rxcap_1258_done + rxcap_1258_fail: + goto rx1253_fail + rxcap_1258_done: + # rx subrule "panic" subtype=method negate= + rx1253_cur."!cursor_pos"(rx1253_pos) + $P10 = rx1253_cur."panic"("Assignment (\"=\") not supported in NQP, use \":=\" instead") + unless $P10, rx1253_fail + rx1253_pos = $P10."pos"() +.annotate 'line', 542 # rx pass - rx1258_cur."!cursor_pass"(rx1258_pos, "prefix:sym") - rx1258_cur."!cursor_debug"("PASS ", "prefix:sym", " at pos=", rx1258_pos) - .return (rx1258_cur) - rx1258_fail: -.annotate 'line', 433 - (rx1258_rep, rx1258_pos, $I10, $P10) = rx1258_cur."!mark_fail"(0) - lt rx1258_pos, -1, rx1258_done - eq rx1258_pos, -1, rx1258_fail + rx1253_cur."!cursor_pass"(rx1253_pos, "infix:sym<=>") + rx1253_cur."!cursor_debug"("PASS ", "infix:sym<=>", " at pos=", rx1253_pos) + .return (rx1253_cur) + rx1253_fail: +.annotate 'line', 445 + (rx1253_rep, rx1253_pos, $I10, $P10) = rx1253_cur."!mark_fail"(0) + lt rx1253_pos, -1, rx1253_done + eq rx1253_pos, -1, rx1253_fail jump $I10 - rx1258_done: - rx1258_cur."!cursor_fail"() - rx1258_cur."!cursor_debug"("FAIL ", "prefix:sym") - .return (rx1258_cur) + rx1253_done: + rx1253_cur."!cursor_fail"() + rx1253_cur."!cursor_debug"("FAIL ", "infix:sym<=>") + .return (rx1253_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__prefix:sym" :subid("324_1275511697.61926") :method -.annotate 'line', 433 - new $P1260, "ResizablePMCArray" - push $P1260, "make" - .return ($P1260) +.sub "!PREFIX__infix:sym<=>" :subid("323_1275600007.84296") :method +.annotate 'line', 445 + $P1255 = self."!PREFIX__!subrule"("", "=") + new $P1256, "ResizablePMCArray" + push $P1256, $P1255 + .return ($P1256) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("325_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1264_tgt - .local int rx1264_pos - .local int rx1264_off - .local int rx1264_eos - .local int rx1264_rep - .local pmc rx1264_cur - (rx1264_cur, rx1264_pos, rx1264_tgt) = self."!cursor_start"() - rx1264_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx1264_cur +.sub "infix:sym<:=>" :subid("324_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1260_tgt + .local int rx1260_pos + .local int rx1260_off + .local int rx1260_eos + .local int rx1260_rep + .local pmc rx1260_cur + (rx1260_cur, rx1260_pos, rx1260_tgt) = self."!cursor_start"() + rx1260_cur."!cursor_debug"("START ", "infix:sym<:=>") + .lex unicode:"$\x{a2}", rx1260_cur .local pmc match .lex "$/", match - length rx1264_eos, rx1264_tgt - gt rx1264_pos, rx1264_eos, rx1264_done - set rx1264_off, 0 - lt rx1264_pos, 2, rx1264_start - sub rx1264_off, rx1264_pos, 1 - substr rx1264_tgt, rx1264_tgt, rx1264_off - rx1264_start: + length rx1260_eos, rx1260_tgt + gt rx1260_pos, rx1260_eos, rx1260_done + set rx1260_off, 0 + lt rx1260_pos, 2, rx1260_start + sub rx1260_off, rx1260_pos, 1 + substr rx1260_tgt, rx1260_tgt, rx1260_off + rx1260_start: $I10 = self.'from'() - ne $I10, -1, rxscan1267_done - goto rxscan1267_scan - rxscan1267_loop: - ($P10) = rx1264_cur."from"() + ne $I10, -1, rxscan1264_done + goto rxscan1264_scan + rxscan1264_loop: + ($P10) = rx1260_cur."from"() inc $P10 - set rx1264_pos, $P10 - ge rx1264_pos, rx1264_eos, rxscan1267_done - rxscan1267_scan: - set_addr $I10, rxscan1267_loop - rx1264_cur."!mark_push"(0, rx1264_pos, $I10) - rxscan1267_done: -.annotate 'line', 540 + set rx1260_pos, $P10 + ge rx1260_pos, rx1260_eos, rxscan1264_done + rxscan1264_scan: + set_addr $I10, rxscan1264_loop + rx1260_cur."!mark_push"(0, rx1260_pos, $I10) + rxscan1264_done: +.annotate 'line', 545 # rx subcapture "sym" - set_addr $I10, rxcap_1268_fail - rx1264_cur."!mark_push"(0, rx1264_pos, $I10) - # rx literal "last" - add $I11, rx1264_pos, 4 - gt $I11, rx1264_eos, rx1264_fail - sub $I11, rx1264_pos, rx1264_off - substr $S10, rx1264_tgt, $I11, 4 - ne $S10, "last", rx1264_fail - add rx1264_pos, 4 - set_addr $I10, rxcap_1268_fail - ($I12, $I11) = rx1264_cur."!mark_peek"($I10) - rx1264_cur."!cursor_pos"($I11) - ($P10) = rx1264_cur."!cursor_start"() - $P10."!cursor_pass"(rx1264_pos, "") - rx1264_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1265_fail + rx1260_cur."!mark_push"(0, rx1260_pos, $I10) + # rx literal ":=" + add $I11, rx1260_pos, 2 + gt $I11, rx1260_eos, rx1260_fail + sub $I11, rx1260_pos, rx1260_off + substr $S10, rx1260_tgt, $I11, 2 + ne $S10, ":=", rx1260_fail + add rx1260_pos, 2 + set_addr $I10, rxcap_1265_fail + ($I12, $I11) = rx1260_cur."!mark_peek"($I10) + rx1260_cur."!cursor_pos"($I11) + ($P10) = rx1260_cur."!cursor_start"() + $P10."!cursor_pass"(rx1260_pos, "") + rx1260_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1268_done - rxcap_1268_fail: - goto rx1264_fail - rxcap_1268_done: + goto rxcap_1265_done + rxcap_1265_fail: + goto rx1260_fail + rxcap_1265_done: + # rx subrule "O" subtype=capture negate= + rx1260_cur."!cursor_pos"(rx1260_pos) + $P10 = rx1260_cur."O"("%assignment, :pasttype") + unless $P10, rx1260_fail + rx1260_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("O") + rx1260_pos = $P10."pos"() # rx pass - rx1264_cur."!cursor_pass"(rx1264_pos, "term:sym") - rx1264_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx1264_pos) - .return (rx1264_cur) - rx1264_fail: -.annotate 'line', 433 - (rx1264_rep, rx1264_pos, $I10, $P10) = rx1264_cur."!mark_fail"(0) - lt rx1264_pos, -1, rx1264_done - eq rx1264_pos, -1, rx1264_fail + rx1260_cur."!cursor_pass"(rx1260_pos, "infix:sym<:=>") + rx1260_cur."!cursor_debug"("PASS ", "infix:sym<:=>", " at pos=", rx1260_pos) + .return (rx1260_cur) + rx1260_fail: +.annotate 'line', 445 + (rx1260_rep, rx1260_pos, $I10, $P10) = rx1260_cur."!mark_fail"(0) + lt rx1260_pos, -1, rx1260_done + eq rx1260_pos, -1, rx1260_fail jump $I10 - rx1264_done: - rx1264_cur."!cursor_fail"() - rx1264_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx1264_cur) + rx1260_done: + rx1260_cur."!cursor_fail"() + rx1260_cur."!cursor_debug"("FAIL ", "infix:sym<:=>") + .return (rx1260_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("326_1275511697.61926") :method -.annotate 'line', 433 - new $P1266, "ResizablePMCArray" - push $P1266, "last" - .return ($P1266) +.sub "!PREFIX__infix:sym<:=>" :subid("325_1275600007.84296") :method +.annotate 'line', 445 + $P1262 = self."!PREFIX__!subrule"("O", ":=") + new $P1263, "ResizablePMCArray" + push $P1263, $P1262 + .return ($P1263) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("327_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1270_tgt - .local int rx1270_pos - .local int rx1270_off - .local int rx1270_eos - .local int rx1270_rep - .local pmc rx1270_cur - (rx1270_cur, rx1270_pos, rx1270_tgt) = self."!cursor_start"() - rx1270_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx1270_cur +.sub "infix:sym<::=>" :subid("326_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1267_tgt + .local int rx1267_pos + .local int rx1267_off + .local int rx1267_eos + .local int rx1267_rep + .local pmc rx1267_cur + (rx1267_cur, rx1267_pos, rx1267_tgt) = self."!cursor_start"() + rx1267_cur."!cursor_debug"("START ", "infix:sym<::=>") + .lex unicode:"$\x{a2}", rx1267_cur .local pmc match .lex "$/", match - length rx1270_eos, rx1270_tgt - gt rx1270_pos, rx1270_eos, rx1270_done - set rx1270_off, 0 - lt rx1270_pos, 2, rx1270_start - sub rx1270_off, rx1270_pos, 1 - substr rx1270_tgt, rx1270_tgt, rx1270_off - rx1270_start: + length rx1267_eos, rx1267_tgt + gt rx1267_pos, rx1267_eos, rx1267_done + set rx1267_off, 0 + lt rx1267_pos, 2, rx1267_start + sub rx1267_off, rx1267_pos, 1 + substr rx1267_tgt, rx1267_tgt, rx1267_off + rx1267_start: $I10 = self.'from'() - ne $I10, -1, rxscan1273_done - goto rxscan1273_scan - rxscan1273_loop: - ($P10) = rx1270_cur."from"() + ne $I10, -1, rxscan1271_done + goto rxscan1271_scan + rxscan1271_loop: + ($P10) = rx1267_cur."from"() inc $P10 - set rx1270_pos, $P10 - ge rx1270_pos, rx1270_eos, rxscan1273_done - rxscan1273_scan: - set_addr $I10, rxscan1273_loop - rx1270_cur."!mark_push"(0, rx1270_pos, $I10) - rxscan1273_done: -.annotate 'line', 541 + set rx1267_pos, $P10 + ge rx1267_pos, rx1267_eos, rxscan1271_done + rxscan1271_scan: + set_addr $I10, rxscan1271_loop + rx1267_cur."!mark_push"(0, rx1267_pos, $I10) + rxscan1271_done: +.annotate 'line', 546 # rx subcapture "sym" - set_addr $I10, rxcap_1274_fail - rx1270_cur."!mark_push"(0, rx1270_pos, $I10) - # rx literal "next" - add $I11, rx1270_pos, 4 - gt $I11, rx1270_eos, rx1270_fail - sub $I11, rx1270_pos, rx1270_off - substr $S10, rx1270_tgt, $I11, 4 - ne $S10, "next", rx1270_fail - add rx1270_pos, 4 - set_addr $I10, rxcap_1274_fail - ($I12, $I11) = rx1270_cur."!mark_peek"($I10) - rx1270_cur."!cursor_pos"($I11) - ($P10) = rx1270_cur."!cursor_start"() - $P10."!cursor_pass"(rx1270_pos, "") - rx1270_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1272_fail + rx1267_cur."!mark_push"(0, rx1267_pos, $I10) + # rx literal "::=" + add $I11, rx1267_pos, 3 + gt $I11, rx1267_eos, rx1267_fail + sub $I11, rx1267_pos, rx1267_off + substr $S10, rx1267_tgt, $I11, 3 + ne $S10, "::=", rx1267_fail + add rx1267_pos, 3 + set_addr $I10, rxcap_1272_fail + ($I12, $I11) = rx1267_cur."!mark_peek"($I10) + rx1267_cur."!cursor_pos"($I11) + ($P10) = rx1267_cur."!cursor_start"() + $P10."!cursor_pass"(rx1267_pos, "") + rx1267_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1274_done - rxcap_1274_fail: - goto rx1270_fail - rxcap_1274_done: + goto rxcap_1272_done + rxcap_1272_fail: + goto rx1267_fail + rxcap_1272_done: + # rx subrule "O" subtype=capture negate= + rx1267_cur."!cursor_pos"(rx1267_pos) + $P10 = rx1267_cur."O"("%assignment, :pasttype") + unless $P10, rx1267_fail + rx1267_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("O") + rx1267_pos = $P10."pos"() # rx pass - rx1270_cur."!cursor_pass"(rx1270_pos, "term:sym") - rx1270_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx1270_pos) - .return (rx1270_cur) - rx1270_fail: -.annotate 'line', 433 - (rx1270_rep, rx1270_pos, $I10, $P10) = rx1270_cur."!mark_fail"(0) - lt rx1270_pos, -1, rx1270_done - eq rx1270_pos, -1, rx1270_fail + rx1267_cur."!cursor_pass"(rx1267_pos, "infix:sym<::=>") + rx1267_cur."!cursor_debug"("PASS ", "infix:sym<::=>", " at pos=", rx1267_pos) + .return (rx1267_cur) + rx1267_fail: +.annotate 'line', 445 + (rx1267_rep, rx1267_pos, $I10, $P10) = rx1267_cur."!mark_fail"(0) + lt rx1267_pos, -1, rx1267_done + eq rx1267_pos, -1, rx1267_fail jump $I10 - rx1270_done: - rx1270_cur."!cursor_fail"() - rx1270_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx1270_cur) + rx1267_done: + rx1267_cur."!cursor_fail"() + rx1267_cur."!cursor_debug"("FAIL ", "infix:sym<::=>") + .return (rx1267_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("328_1275511697.61926") :method -.annotate 'line', 433 - new $P1272, "ResizablePMCArray" - push $P1272, "next" - .return ($P1272) +.sub "!PREFIX__infix:sym<::=>" :subid("327_1275600007.84296") :method +.annotate 'line', 445 + $P1269 = self."!PREFIX__!subrule"("O", "::=") + new $P1270, "ResizablePMCArray" + push $P1270, $P1269 + .return ($P1270) .end .namespace ["NQP";"Grammar"] -.sub "term:sym" :subid("329_1275511697.61926") :method :outer("11_1275511697.61926") -.annotate 'line', 433 - .local string rx1276_tgt - .local int rx1276_pos - .local int rx1276_off - .local int rx1276_eos - .local int rx1276_rep - .local pmc rx1276_cur - (rx1276_cur, rx1276_pos, rx1276_tgt) = self."!cursor_start"() - rx1276_cur."!cursor_debug"("START ", "term:sym") - .lex unicode:"$\x{a2}", rx1276_cur +.sub "infix:sym<,>" :subid("328_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1274_tgt + .local int rx1274_pos + .local int rx1274_off + .local int rx1274_eos + .local int rx1274_rep + .local pmc rx1274_cur + (rx1274_cur, rx1274_pos, rx1274_tgt) = self."!cursor_start"() + rx1274_cur."!cursor_debug"("START ", "infix:sym<,>") + .lex unicode:"$\x{a2}", rx1274_cur .local pmc match .lex "$/", match - length rx1276_eos, rx1276_tgt - gt rx1276_pos, rx1276_eos, rx1276_done - set rx1276_off, 0 - lt rx1276_pos, 2, rx1276_start - sub rx1276_off, rx1276_pos, 1 - substr rx1276_tgt, rx1276_tgt, rx1276_off - rx1276_start: + length rx1274_eos, rx1274_tgt + gt rx1274_pos, rx1274_eos, rx1274_done + set rx1274_off, 0 + lt rx1274_pos, 2, rx1274_start + sub rx1274_off, rx1274_pos, 1 + substr rx1274_tgt, rx1274_tgt, rx1274_off + rx1274_start: $I10 = self.'from'() - ne $I10, -1, rxscan1279_done - goto rxscan1279_scan - rxscan1279_loop: - ($P10) = rx1276_cur."from"() + ne $I10, -1, rxscan1278_done + goto rxscan1278_scan + rxscan1278_loop: + ($P10) = rx1274_cur."from"() inc $P10 - set rx1276_pos, $P10 - ge rx1276_pos, rx1276_eos, rxscan1279_done - rxscan1279_scan: - set_addr $I10, rxscan1279_loop - rx1276_cur."!mark_push"(0, rx1276_pos, $I10) - rxscan1279_done: -.annotate 'line', 542 + set rx1274_pos, $P10 + ge rx1274_pos, rx1274_eos, rxscan1278_done + rxscan1278_scan: + set_addr $I10, rxscan1278_loop + rx1274_cur."!mark_push"(0, rx1274_pos, $I10) + rxscan1278_done: +.annotate 'line', 548 # rx subcapture "sym" - set_addr $I10, rxcap_1280_fail - rx1276_cur."!mark_push"(0, rx1276_pos, $I10) - # rx literal "redo" - add $I11, rx1276_pos, 4 - gt $I11, rx1276_eos, rx1276_fail - sub $I11, rx1276_pos, rx1276_off - substr $S10, rx1276_tgt, $I11, 4 - ne $S10, "redo", rx1276_fail - add rx1276_pos, 4 - set_addr $I10, rxcap_1280_fail - ($I12, $I11) = rx1276_cur."!mark_peek"($I10) - rx1276_cur."!cursor_pos"($I11) - ($P10) = rx1276_cur."!cursor_start"() - $P10."!cursor_pass"(rx1276_pos, "") - rx1276_cur."!mark_push"(0, -1, 0, $P10) + set_addr $I10, rxcap_1279_fail + rx1274_cur."!mark_push"(0, rx1274_pos, $I10) + # rx literal "," + add $I11, rx1274_pos, 1 + gt $I11, rx1274_eos, rx1274_fail + sub $I11, rx1274_pos, rx1274_off + substr $S10, rx1274_tgt, $I11, 1 + ne $S10, ",", rx1274_fail + add rx1274_pos, 1 + set_addr $I10, rxcap_1279_fail + ($I12, $I11) = rx1274_cur."!mark_peek"($I10) + rx1274_cur."!cursor_pos"($I11) + ($P10) = rx1274_cur."!cursor_start"() + $P10."!cursor_pass"(rx1274_pos, "") + rx1274_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_1280_done - rxcap_1280_fail: - goto rx1276_fail - rxcap_1280_done: + goto rxcap_1279_done + rxcap_1279_fail: + goto rx1274_fail + rxcap_1279_done: + # rx subrule "O" subtype=capture negate= + rx1274_cur."!cursor_pos"(rx1274_pos) + $P10 = rx1274_cur."O"("%comma, :pasttype") + unless $P10, rx1274_fail + rx1274_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("O") + rx1274_pos = $P10."pos"() # rx pass - rx1276_cur."!cursor_pass"(rx1276_pos, "term:sym") - rx1276_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx1276_pos) - .return (rx1276_cur) - rx1276_fail: -.annotate 'line', 433 - (rx1276_rep, rx1276_pos, $I10, $P10) = rx1276_cur."!mark_fail"(0) - lt rx1276_pos, -1, rx1276_done - eq rx1276_pos, -1, rx1276_fail + rx1274_cur."!cursor_pass"(rx1274_pos, "infix:sym<,>") + rx1274_cur."!cursor_debug"("PASS ", "infix:sym<,>", " at pos=", rx1274_pos) + .return (rx1274_cur) + rx1274_fail: +.annotate 'line', 445 + (rx1274_rep, rx1274_pos, $I10, $P10) = rx1274_cur."!mark_fail"(0) + lt rx1274_pos, -1, rx1274_done + eq rx1274_pos, -1, rx1274_fail jump $I10 - rx1276_done: - rx1276_cur."!cursor_fail"() - rx1276_cur."!cursor_debug"("FAIL ", "term:sym") - .return (rx1276_cur) + rx1274_done: + rx1274_cur."!cursor_fail"() + rx1274_cur."!cursor_debug"("FAIL ", "infix:sym<,>") + .return (rx1274_cur) .return () .end .namespace ["NQP";"Grammar"] -.sub "!PREFIX__term:sym" :subid("330_1275511697.61926") :method -.annotate 'line', 433 - new $P1278, "ResizablePMCArray" - push $P1278, "redo" - .return ($P1278) +.sub "!PREFIX__infix:sym<,>" :subid("329_1275600007.84296") :method +.annotate 'line', 445 + $P1276 = self."!PREFIX__!subrule"("O", ",") + new $P1277, "ResizablePMCArray" + push $P1277, $P1276 + .return ($P1277) .end .namespace ["NQP";"Grammar"] -.sub "smartmatch" :subid("331_1275511697.61926") :method :outer("11_1275511697.61926") - .param pmc param_1284 -.annotate 'line', 544 - new $P1283, 'ExceptionHandler' - set_addr $P1283, control_1282 - $P1283."handle_types"(57) - push_eh $P1283 - .lex "self", self - .lex "$/", param_1284 -.annotate 'line', 546 - new $P1285, "Undef" - .lex "$t", $P1285 - find_lex $P1286, "$/" - unless_null $P1286, vivify_367 - $P1286 = root_new ['parrot';'ResizablePMCArray'] - vivify_367: - set $P1287, $P1286[0] - unless_null $P1287, vivify_368 - new $P1287, "Undef" - vivify_368: - store_lex "$t", $P1287 - find_lex $P1288, "$/" - unless_null $P1288, vivify_369 - $P1288 = root_new ['parrot';'ResizablePMCArray'] - vivify_369: - set $P1289, $P1288[1] - unless_null $P1289, vivify_370 - new $P1289, "Undef" - vivify_370: - find_lex $P1290, "$/" - unless_null $P1290, vivify_371 - $P1290 = root_new ['parrot';'ResizablePMCArray'] - store_lex "$/", $P1290 - vivify_371: - set $P1290[0], $P1289 - find_lex $P1291, "$t" - find_lex $P1292, "$/" - unless_null $P1292, vivify_372 - $P1292 = root_new ['parrot';'ResizablePMCArray'] - store_lex "$/", $P1292 - vivify_372: - set $P1292[1], $P1291 -.annotate 'line', 544 - .return ($P1291) - control_1282: - .local pmc exception - .get_results (exception) - getattribute $P1293, exception, "payload" - .return ($P1293) -.end - - -.namespace ["NQP";"Regex"] -.sub "_block1294" :subid("332_1275511697.61926") :outer("11_1275511697.61926") -.annotate 'line', 550 - .const 'Sub' $P1352 = "351_1275511697.61926" - capture_lex $P1352 - .const 'Sub' $P1347 = "349_1275511697.61926" - capture_lex $P1347 - .const 'Sub' $P1334 = "346_1275511697.61926" - capture_lex $P1334 - .const 'Sub' $P1324 = "343_1275511697.61926" - capture_lex $P1324 - .const 'Sub' $P1319 = "341_1275511697.61926" - capture_lex $P1319 - .const 'Sub' $P1310 = "338_1275511697.61926" - capture_lex $P1310 - .const 'Sub' $P1305 = "336_1275511697.61926" - capture_lex $P1305 - .const 'Sub' $P1296 = "333_1275511697.61926" - capture_lex $P1296 - .const 'Sub' $P1352 = "351_1275511697.61926" - capture_lex $P1352 - .return ($P1352) -.end - - -.namespace ["NQP";"Regex"] -.sub "metachar:sym<:my>" :subid("333_1275511697.61926") :method :outer("332_1275511697.61926") -.annotate 'line', 550 - .const 'Sub' $P1302 = "335_1275511697.61926" - capture_lex $P1302 - .local string rx1297_tgt - .local int rx1297_pos - .local int rx1297_off - .local int rx1297_eos - .local int rx1297_rep - .local pmc rx1297_cur - (rx1297_cur, rx1297_pos, rx1297_tgt) = self."!cursor_start"() - rx1297_cur."!cursor_debug"("START ", "metachar:sym<:my>") - .lex unicode:"$\x{a2}", rx1297_cur +.sub "prefix:sym" :subid("330_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1281_tgt + .local int rx1281_pos + .local int rx1281_off + .local int rx1281_eos + .local int rx1281_rep + .local pmc rx1281_cur + (rx1281_cur, rx1281_pos, rx1281_tgt) = self."!cursor_start"() + rx1281_cur."!cursor_debug"("START ", "prefix:sym") + .lex unicode:"$\x{a2}", rx1281_cur .local pmc match .lex "$/", match - length rx1297_eos, rx1297_tgt - gt rx1297_pos, rx1297_eos, rx1297_done - set rx1297_off, 0 - lt rx1297_pos, 2, rx1297_start - sub rx1297_off, rx1297_pos, 1 - substr rx1297_tgt, rx1297_tgt, rx1297_off - rx1297_start: + length rx1281_eos, rx1281_tgt + gt rx1281_pos, rx1281_eos, rx1281_done + set rx1281_off, 0 + lt rx1281_pos, 2, rx1281_start + sub rx1281_off, rx1281_pos, 1 + substr rx1281_tgt, rx1281_tgt, rx1281_off + rx1281_start: $I10 = self.'from'() - ne $I10, -1, rxscan1300_done - goto rxscan1300_scan - rxscan1300_loop: - ($P10) = rx1297_cur."from"() + ne $I10, -1, rxscan1284_done + goto rxscan1284_scan + rxscan1284_loop: + ($P10) = rx1281_cur."from"() inc $P10 - set rx1297_pos, $P10 - ge rx1297_pos, rx1297_eos, rxscan1300_done - rxscan1300_scan: - set_addr $I10, rxscan1300_loop - rx1297_cur."!mark_push"(0, rx1297_pos, $I10) - rxscan1300_done: -.annotate 'line', 552 - # rx literal ":" - add $I11, rx1297_pos, 1 - gt $I11, rx1297_eos, rx1297_fail - sub $I11, rx1297_pos, rx1297_off - substr $S10, rx1297_tgt, $I11, 1 - ne $S10, ":", rx1297_fail - add rx1297_pos, 1 - # rx subrule "before" subtype=zerowidth negate= - rx1297_cur."!cursor_pos"(rx1297_pos) - .const 'Sub' $P1302 = "335_1275511697.61926" - capture_lex $P1302 - $P10 = rx1297_cur."before"($P1302) - unless $P10, rx1297_fail - # rx subrule "LANG" subtype=capture negate= - rx1297_cur."!cursor_pos"(rx1297_pos) - $P10 = rx1297_cur."LANG"("MAIN", "statement") - unless $P10, rx1297_fail - rx1297_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("statement") - rx1297_pos = $P10."pos"() - # rx subrule "ws" subtype=method negate= - rx1297_cur."!cursor_pos"(rx1297_pos) - $P10 = rx1297_cur."ws"() - unless $P10, rx1297_fail - rx1297_pos = $P10."pos"() - # rx literal ";" - add $I11, rx1297_pos, 1 - gt $I11, rx1297_eos, rx1297_fail - sub $I11, rx1297_pos, rx1297_off - substr $S10, rx1297_tgt, $I11, 1 - ne $S10, ";", rx1297_fail - add rx1297_pos, 1 -.annotate 'line', 551 - # rx pass - rx1297_cur."!cursor_pass"(rx1297_pos, "metachar:sym<:my>") - rx1297_cur."!cursor_debug"("PASS ", "metachar:sym<:my>", " at pos=", rx1297_pos) - .return (rx1297_cur) - rx1297_fail: + set rx1281_pos, $P10 + ge rx1281_pos, rx1281_eos, rxscan1284_done + rxscan1284_scan: + set_addr $I10, rxscan1284_loop + rx1281_cur."!mark_push"(0, rx1281_pos, $I10) + rxscan1284_done: .annotate 'line', 550 - (rx1297_rep, rx1297_pos, $I10, $P10) = rx1297_cur."!mark_fail"(0) - lt rx1297_pos, -1, rx1297_done - eq rx1297_pos, -1, rx1297_fail + # rx subcapture "sym" + set_addr $I10, rxcap_1285_fail + rx1281_cur."!mark_push"(0, rx1281_pos, $I10) + # rx literal "return" + add $I11, rx1281_pos, 6 + gt $I11, rx1281_eos, rx1281_fail + sub $I11, rx1281_pos, rx1281_off + substr $S10, rx1281_tgt, $I11, 6 + ne $S10, "return", rx1281_fail + add rx1281_pos, 6 + set_addr $I10, rxcap_1285_fail + ($I12, $I11) = rx1281_cur."!mark_peek"($I10) + rx1281_cur."!cursor_pos"($I11) + ($P10) = rx1281_cur."!cursor_start"() + $P10."!cursor_pass"(rx1281_pos, "") + rx1281_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("sym") + goto rxcap_1285_done + rxcap_1285_fail: + goto rx1281_fail + rxcap_1285_done: + # rx charclass s + ge rx1281_pos, rx1281_eos, rx1281_fail + sub $I10, rx1281_pos, rx1281_off + is_cclass $I11, 32, rx1281_tgt, $I10 + unless $I11, rx1281_fail + inc rx1281_pos + # rx subrule "O" subtype=capture negate= + rx1281_cur."!cursor_pos"(rx1281_pos) + $P10 = rx1281_cur."O"("%list_prefix, :pasttype") + unless $P10, rx1281_fail + rx1281_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("O") + rx1281_pos = $P10."pos"() + # rx pass + rx1281_cur."!cursor_pass"(rx1281_pos, "prefix:sym") + rx1281_cur."!cursor_debug"("PASS ", "prefix:sym", " at pos=", rx1281_pos) + .return (rx1281_cur) + rx1281_fail: +.annotate 'line', 445 + (rx1281_rep, rx1281_pos, $I10, $P10) = rx1281_cur."!mark_fail"(0) + lt rx1281_pos, -1, rx1281_done + eq rx1281_pos, -1, rx1281_fail jump $I10 - rx1297_done: - rx1297_cur."!cursor_fail"() - rx1297_cur."!cursor_debug"("FAIL ", "metachar:sym<:my>") - .return (rx1297_cur) + rx1281_done: + rx1281_cur."!cursor_fail"() + rx1281_cur."!cursor_debug"("FAIL ", "prefix:sym") + .return (rx1281_cur) .return () .end -.namespace ["NQP";"Regex"] -.sub "!PREFIX__metachar:sym<:my>" :subid("334_1275511697.61926") :method -.annotate 'line', 550 - new $P1299, "ResizablePMCArray" - push $P1299, ":" - .return ($P1299) +.namespace ["NQP";"Grammar"] +.sub "!PREFIX__prefix:sym" :subid("331_1275600007.84296") :method +.annotate 'line', 445 + new $P1283, "ResizablePMCArray" + push $P1283, "return" + .return ($P1283) .end -.namespace ["NQP";"Regex"] -.sub "_block1301" :anon :subid("335_1275511697.61926") :method :outer("333_1275511697.61926") -.annotate 'line', 552 - .local string rx1303_tgt - .local int rx1303_pos - .local int rx1303_off - .local int rx1303_eos - .local int rx1303_rep - .local pmc rx1303_cur - (rx1303_cur, rx1303_pos, rx1303_tgt) = self."!cursor_start"() - rx1303_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx1303_cur +.namespace ["NQP";"Grammar"] +.sub "prefix:sym" :subid("332_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1287_tgt + .local int rx1287_pos + .local int rx1287_off + .local int rx1287_eos + .local int rx1287_rep + .local pmc rx1287_cur + (rx1287_cur, rx1287_pos, rx1287_tgt) = self."!cursor_start"() + rx1287_cur."!cursor_debug"("START ", "prefix:sym") + .lex unicode:"$\x{a2}", rx1287_cur .local pmc match .lex "$/", match - length rx1303_eos, rx1303_tgt - gt rx1303_pos, rx1303_eos, rx1303_done - set rx1303_off, 0 - lt rx1303_pos, 2, rx1303_start - sub rx1303_off, rx1303_pos, 1 - substr rx1303_tgt, rx1303_tgt, rx1303_off - rx1303_start: + length rx1287_eos, rx1287_tgt + gt rx1287_pos, rx1287_eos, rx1287_done + set rx1287_off, 0 + lt rx1287_pos, 2, rx1287_start + sub rx1287_off, rx1287_pos, 1 + substr rx1287_tgt, rx1287_tgt, rx1287_off + rx1287_start: $I10 = self.'from'() - ne $I10, -1, rxscan1304_done - goto rxscan1304_scan - rxscan1304_loop: - ($P10) = rx1303_cur."from"() + ne $I10, -1, rxscan1290_done + goto rxscan1290_scan + rxscan1290_loop: + ($P10) = rx1287_cur."from"() inc $P10 - set rx1303_pos, $P10 - ge rx1303_pos, rx1303_eos, rxscan1304_done - rxscan1304_scan: - set_addr $I10, rxscan1304_loop - rx1303_cur."!mark_push"(0, rx1303_pos, $I10) - rxscan1304_done: - # rx literal "my" - add $I11, rx1303_pos, 2 - gt $I11, rx1303_eos, rx1303_fail - sub $I11, rx1303_pos, rx1303_off - substr $S10, rx1303_tgt, $I11, 2 - ne $S10, "my", rx1303_fail - add rx1303_pos, 2 + set rx1287_pos, $P10 + ge rx1287_pos, rx1287_eos, rxscan1290_done + rxscan1290_scan: + set_addr $I10, rxscan1290_loop + rx1287_cur."!mark_push"(0, rx1287_pos, $I10) + rxscan1290_done: +.annotate 'line', 551 + # rx subcapture "sym" + set_addr $I10, rxcap_1291_fail + rx1287_cur."!mark_push"(0, rx1287_pos, $I10) + # rx literal "make" + add $I11, rx1287_pos, 4 + gt $I11, rx1287_eos, rx1287_fail + sub $I11, rx1287_pos, rx1287_off + substr $S10, rx1287_tgt, $I11, 4 + ne $S10, "make", rx1287_fail + add rx1287_pos, 4 + set_addr $I10, rxcap_1291_fail + ($I12, $I11) = rx1287_cur."!mark_peek"($I10) + rx1287_cur."!cursor_pos"($I11) + ($P10) = rx1287_cur."!cursor_start"() + $P10."!cursor_pass"(rx1287_pos, "") + rx1287_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("sym") + goto rxcap_1291_done + rxcap_1291_fail: + goto rx1287_fail + rxcap_1291_done: + # rx charclass s + ge rx1287_pos, rx1287_eos, rx1287_fail + sub $I10, rx1287_pos, rx1287_off + is_cclass $I11, 32, rx1287_tgt, $I10 + unless $I11, rx1287_fail + inc rx1287_pos + # rx subrule "O" subtype=capture negate= + rx1287_cur."!cursor_pos"(rx1287_pos) + $P10 = rx1287_cur."O"("%list_prefix") + unless $P10, rx1287_fail + rx1287_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("O") + rx1287_pos = $P10."pos"() # rx pass - rx1303_cur."!cursor_pass"(rx1303_pos, "") - rx1303_cur."!cursor_debug"("PASS ", "", " at pos=", rx1303_pos) - .return (rx1303_cur) - rx1303_fail: - (rx1303_rep, rx1303_pos, $I10, $P10) = rx1303_cur."!mark_fail"(0) - lt rx1303_pos, -1, rx1303_done - eq rx1303_pos, -1, rx1303_fail + rx1287_cur."!cursor_pass"(rx1287_pos, "prefix:sym") + rx1287_cur."!cursor_debug"("PASS ", "prefix:sym", " at pos=", rx1287_pos) + .return (rx1287_cur) + rx1287_fail: +.annotate 'line', 445 + (rx1287_rep, rx1287_pos, $I10, $P10) = rx1287_cur."!mark_fail"(0) + lt rx1287_pos, -1, rx1287_done + eq rx1287_pos, -1, rx1287_fail jump $I10 - rx1303_done: - rx1303_cur."!cursor_fail"() - rx1303_cur."!cursor_debug"("FAIL ", "") - .return (rx1303_cur) + rx1287_done: + rx1287_cur."!cursor_fail"() + rx1287_cur."!cursor_debug"("FAIL ", "prefix:sym") + .return (rx1287_cur) .return () .end -.namespace ["NQP";"Regex"] -.sub "metachar:sym<{ }>" :subid("336_1275511697.61926") :method :outer("332_1275511697.61926") -.annotate 'line', 550 - .local string rx1306_tgt - .local int rx1306_pos - .local int rx1306_off - .local int rx1306_eos - .local int rx1306_rep - .local pmc rx1306_cur - (rx1306_cur, rx1306_pos, rx1306_tgt) = self."!cursor_start"() - rx1306_cur."!cursor_debug"("START ", "metachar:sym<{ }>") - .lex unicode:"$\x{a2}", rx1306_cur +.namespace ["NQP";"Grammar"] +.sub "!PREFIX__prefix:sym" :subid("333_1275600007.84296") :method +.annotate 'line', 445 + new $P1289, "ResizablePMCArray" + push $P1289, "make" + .return ($P1289) +.end + + +.namespace ["NQP";"Grammar"] +.sub "term:sym" :subid("334_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1293_tgt + .local int rx1293_pos + .local int rx1293_off + .local int rx1293_eos + .local int rx1293_rep + .local pmc rx1293_cur + (rx1293_cur, rx1293_pos, rx1293_tgt) = self."!cursor_start"() + rx1293_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx1293_cur .local pmc match .lex "$/", match - length rx1306_eos, rx1306_tgt - gt rx1306_pos, rx1306_eos, rx1306_done - set rx1306_off, 0 - lt rx1306_pos, 2, rx1306_start - sub rx1306_off, rx1306_pos, 1 - substr rx1306_tgt, rx1306_tgt, rx1306_off - rx1306_start: + length rx1293_eos, rx1293_tgt + gt rx1293_pos, rx1293_eos, rx1293_done + set rx1293_off, 0 + lt rx1293_pos, 2, rx1293_start + sub rx1293_off, rx1293_pos, 1 + substr rx1293_tgt, rx1293_tgt, rx1293_off + rx1293_start: $I10 = self.'from'() - ne $I10, -1, rxscan1309_done - goto rxscan1309_scan - rxscan1309_loop: - ($P10) = rx1306_cur."from"() + ne $I10, -1, rxscan1296_done + goto rxscan1296_scan + rxscan1296_loop: + ($P10) = rx1293_cur."from"() inc $P10 - set rx1306_pos, $P10 - ge rx1306_pos, rx1306_eos, rxscan1309_done - rxscan1309_scan: - set_addr $I10, rxscan1309_loop - rx1306_cur."!mark_push"(0, rx1306_pos, $I10) - rxscan1309_done: -.annotate 'line', 556 - # rx enumcharlist negate=0 zerowidth - ge rx1306_pos, rx1306_eos, rx1306_fail - sub $I10, rx1306_pos, rx1306_off - substr $S10, rx1306_tgt, $I10, 1 - index $I11, "{", $S10 - lt $I11, 0, rx1306_fail - # rx subrule "codeblock" subtype=capture negate= - rx1306_cur."!cursor_pos"(rx1306_pos) - $P10 = rx1306_cur."codeblock"() - unless $P10, rx1306_fail - rx1306_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("codeblock") - rx1306_pos = $P10."pos"() -.annotate 'line', 555 + set rx1293_pos, $P10 + ge rx1293_pos, rx1293_eos, rxscan1296_done + rxscan1296_scan: + set_addr $I10, rxscan1296_loop + rx1293_cur."!mark_push"(0, rx1293_pos, $I10) + rxscan1296_done: +.annotate 'line', 552 + # rx subcapture "sym" + set_addr $I10, rxcap_1297_fail + rx1293_cur."!mark_push"(0, rx1293_pos, $I10) + # rx literal "last" + add $I11, rx1293_pos, 4 + gt $I11, rx1293_eos, rx1293_fail + sub $I11, rx1293_pos, rx1293_off + substr $S10, rx1293_tgt, $I11, 4 + ne $S10, "last", rx1293_fail + add rx1293_pos, 4 + set_addr $I10, rxcap_1297_fail + ($I12, $I11) = rx1293_cur."!mark_peek"($I10) + rx1293_cur."!cursor_pos"($I11) + ($P10) = rx1293_cur."!cursor_start"() + $P10."!cursor_pass"(rx1293_pos, "") + rx1293_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("sym") + goto rxcap_1297_done + rxcap_1297_fail: + goto rx1293_fail + rxcap_1297_done: # rx pass - rx1306_cur."!cursor_pass"(rx1306_pos, "metachar:sym<{ }>") - rx1306_cur."!cursor_debug"("PASS ", "metachar:sym<{ }>", " at pos=", rx1306_pos) - .return (rx1306_cur) - rx1306_fail: -.annotate 'line', 550 - (rx1306_rep, rx1306_pos, $I10, $P10) = rx1306_cur."!mark_fail"(0) - lt rx1306_pos, -1, rx1306_done - eq rx1306_pos, -1, rx1306_fail + rx1293_cur."!cursor_pass"(rx1293_pos, "term:sym") + rx1293_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx1293_pos) + .return (rx1293_cur) + rx1293_fail: +.annotate 'line', 445 + (rx1293_rep, rx1293_pos, $I10, $P10) = rx1293_cur."!mark_fail"(0) + lt rx1293_pos, -1, rx1293_done + eq rx1293_pos, -1, rx1293_fail jump $I10 - rx1306_done: - rx1306_cur."!cursor_fail"() - rx1306_cur."!cursor_debug"("FAIL ", "metachar:sym<{ }>") - .return (rx1306_cur) + rx1293_done: + rx1293_cur."!cursor_fail"() + rx1293_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx1293_cur) .return () .end -.namespace ["NQP";"Regex"] -.sub "!PREFIX__metachar:sym<{ }>" :subid("337_1275511697.61926") :method -.annotate 'line', 550 - new $P1308, "ResizablePMCArray" - push $P1308, "{" - .return ($P1308) +.namespace ["NQP";"Grammar"] +.sub "!PREFIX__term:sym" :subid("335_1275600007.84296") :method +.annotate 'line', 445 + new $P1295, "ResizablePMCArray" + push $P1295, "last" + .return ($P1295) .end -.namespace ["NQP";"Regex"] -.sub "metachar:sym" :subid("338_1275511697.61926") :method :outer("332_1275511697.61926") -.annotate 'line', 550 - .const 'Sub' $P1316 = "340_1275511697.61926" - capture_lex $P1316 - .local string rx1311_tgt - .local int rx1311_pos - .local int rx1311_off - .local int rx1311_eos - .local int rx1311_rep - .local pmc rx1311_cur - (rx1311_cur, rx1311_pos, rx1311_tgt) = self."!cursor_start"() - rx1311_cur."!cursor_debug"("START ", "metachar:sym") - .lex unicode:"$\x{a2}", rx1311_cur +.namespace ["NQP";"Grammar"] +.sub "term:sym" :subid("336_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1299_tgt + .local int rx1299_pos + .local int rx1299_off + .local int rx1299_eos + .local int rx1299_rep + .local pmc rx1299_cur + (rx1299_cur, rx1299_pos, rx1299_tgt) = self."!cursor_start"() + rx1299_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx1299_cur .local pmc match .lex "$/", match - length rx1311_eos, rx1311_tgt - gt rx1311_pos, rx1311_eos, rx1311_done - set rx1311_off, 0 - lt rx1311_pos, 2, rx1311_start - sub rx1311_off, rx1311_pos, 1 - substr rx1311_tgt, rx1311_tgt, rx1311_off - rx1311_start: + length rx1299_eos, rx1299_tgt + gt rx1299_pos, rx1299_eos, rx1299_done + set rx1299_off, 0 + lt rx1299_pos, 2, rx1299_start + sub rx1299_off, rx1299_pos, 1 + substr rx1299_tgt, rx1299_tgt, rx1299_off + rx1299_start: $I10 = self.'from'() - ne $I10, -1, rxscan1314_done - goto rxscan1314_scan - rxscan1314_loop: - ($P10) = rx1311_cur."from"() + ne $I10, -1, rxscan1302_done + goto rxscan1302_scan + rxscan1302_loop: + ($P10) = rx1299_cur."from"() inc $P10 - set rx1311_pos, $P10 - ge rx1311_pos, rx1311_eos, rxscan1314_done - rxscan1314_scan: - set_addr $I10, rxscan1314_loop - rx1311_cur."!mark_push"(0, rx1311_pos, $I10) - rxscan1314_done: -.annotate 'line', 560 - # rx enumcharlist negate=0 zerowidth - ge rx1311_pos, rx1311_eos, rx1311_fail - sub $I10, rx1311_pos, rx1311_off - substr $S10, rx1311_tgt, $I10, 1 - index $I11, "$@", $S10 - lt $I11, 0, rx1311_fail - # rx subrule "before" subtype=zerowidth negate= - rx1311_cur."!cursor_pos"(rx1311_pos) - .const 'Sub' $P1316 = "340_1275511697.61926" - capture_lex $P1316 - $P10 = rx1311_cur."before"($P1316) - unless $P10, rx1311_fail - # rx subrule "LANG" subtype=capture negate= - rx1311_cur."!cursor_pos"(rx1311_pos) - $P10 = rx1311_cur."LANG"("MAIN", "variable") - unless $P10, rx1311_fail - rx1311_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("var") - rx1311_pos = $P10."pos"() -.annotate 'line', 559 + set rx1299_pos, $P10 + ge rx1299_pos, rx1299_eos, rxscan1302_done + rxscan1302_scan: + set_addr $I10, rxscan1302_loop + rx1299_cur."!mark_push"(0, rx1299_pos, $I10) + rxscan1302_done: +.annotate 'line', 553 + # rx subcapture "sym" + set_addr $I10, rxcap_1303_fail + rx1299_cur."!mark_push"(0, rx1299_pos, $I10) + # rx literal "next" + add $I11, rx1299_pos, 4 + gt $I11, rx1299_eos, rx1299_fail + sub $I11, rx1299_pos, rx1299_off + substr $S10, rx1299_tgt, $I11, 4 + ne $S10, "next", rx1299_fail + add rx1299_pos, 4 + set_addr $I10, rxcap_1303_fail + ($I12, $I11) = rx1299_cur."!mark_peek"($I10) + rx1299_cur."!cursor_pos"($I11) + ($P10) = rx1299_cur."!cursor_start"() + $P10."!cursor_pass"(rx1299_pos, "") + rx1299_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("sym") + goto rxcap_1303_done + rxcap_1303_fail: + goto rx1299_fail + rxcap_1303_done: # rx pass - rx1311_cur."!cursor_pass"(rx1311_pos, "metachar:sym") - rx1311_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx1311_pos) - .return (rx1311_cur) - rx1311_fail: -.annotate 'line', 550 - (rx1311_rep, rx1311_pos, $I10, $P10) = rx1311_cur."!mark_fail"(0) - lt rx1311_pos, -1, rx1311_done - eq rx1311_pos, -1, rx1311_fail + rx1299_cur."!cursor_pass"(rx1299_pos, "term:sym") + rx1299_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx1299_pos) + .return (rx1299_cur) + rx1299_fail: +.annotate 'line', 445 + (rx1299_rep, rx1299_pos, $I10, $P10) = rx1299_cur."!mark_fail"(0) + lt rx1299_pos, -1, rx1299_done + eq rx1299_pos, -1, rx1299_fail jump $I10 - rx1311_done: - rx1311_cur."!cursor_fail"() - rx1311_cur."!cursor_debug"("FAIL ", "metachar:sym") - .return (rx1311_cur) + rx1299_done: + rx1299_cur."!cursor_fail"() + rx1299_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx1299_cur) .return () .end -.namespace ["NQP";"Regex"] -.sub "!PREFIX__metachar:sym" :subid("339_1275511697.61926") :method -.annotate 'line', 550 - new $P1313, "ResizablePMCArray" - push $P1313, "$" - push $P1313, "@" - .return ($P1313) +.namespace ["NQP";"Grammar"] +.sub "!PREFIX__term:sym" :subid("337_1275600007.84296") :method +.annotate 'line', 445 + new $P1301, "ResizablePMCArray" + push $P1301, "next" + .return ($P1301) .end -.namespace ["NQP";"Regex"] -.sub "_block1315" :anon :subid("340_1275511697.61926") :method :outer("338_1275511697.61926") -.annotate 'line', 560 - .local string rx1317_tgt - .local int rx1317_pos - .local int rx1317_off - .local int rx1317_eos - .local int rx1317_rep - .local pmc rx1317_cur - (rx1317_cur, rx1317_pos, rx1317_tgt) = self."!cursor_start"() - rx1317_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx1317_cur +.namespace ["NQP";"Grammar"] +.sub "term:sym" :subid("338_1275600007.84296") :method :outer("11_1275600007.84296") +.annotate 'line', 445 + .local string rx1305_tgt + .local int rx1305_pos + .local int rx1305_off + .local int rx1305_eos + .local int rx1305_rep + .local pmc rx1305_cur + (rx1305_cur, rx1305_pos, rx1305_tgt) = self."!cursor_start"() + rx1305_cur."!cursor_debug"("START ", "term:sym") + .lex unicode:"$\x{a2}", rx1305_cur .local pmc match .lex "$/", match - length rx1317_eos, rx1317_tgt - gt rx1317_pos, rx1317_eos, rx1317_done - set rx1317_off, 0 - lt rx1317_pos, 2, rx1317_start - sub rx1317_off, rx1317_pos, 1 - substr rx1317_tgt, rx1317_tgt, rx1317_off - rx1317_start: + length rx1305_eos, rx1305_tgt + gt rx1305_pos, rx1305_eos, rx1305_done + set rx1305_off, 0 + lt rx1305_pos, 2, rx1305_start + sub rx1305_off, rx1305_pos, 1 + substr rx1305_tgt, rx1305_tgt, rx1305_off + rx1305_start: $I10 = self.'from'() - ne $I10, -1, rxscan1318_done - goto rxscan1318_scan - rxscan1318_loop: - ($P10) = rx1317_cur."from"() + ne $I10, -1, rxscan1308_done + goto rxscan1308_scan + rxscan1308_loop: + ($P10) = rx1305_cur."from"() inc $P10 - set rx1317_pos, $P10 - ge rx1317_pos, rx1317_eos, rxscan1318_done - rxscan1318_scan: - set_addr $I10, rxscan1318_loop - rx1317_cur."!mark_push"(0, rx1317_pos, $I10) - rxscan1318_done: - # rx charclass . - ge rx1317_pos, rx1317_eos, rx1317_fail - inc rx1317_pos - # rx charclass w - ge rx1317_pos, rx1317_eos, rx1317_fail - sub $I10, rx1317_pos, rx1317_off - is_cclass $I11, 8192, rx1317_tgt, $I10 - unless $I11, rx1317_fail - inc rx1317_pos + set rx1305_pos, $P10 + ge rx1305_pos, rx1305_eos, rxscan1308_done + rxscan1308_scan: + set_addr $I10, rxscan1308_loop + rx1305_cur."!mark_push"(0, rx1305_pos, $I10) + rxscan1308_done: +.annotate 'line', 554 + # rx subcapture "sym" + set_addr $I10, rxcap_1309_fail + rx1305_cur."!mark_push"(0, rx1305_pos, $I10) + # rx literal "redo" + add $I11, rx1305_pos, 4 + gt $I11, rx1305_eos, rx1305_fail + sub $I11, rx1305_pos, rx1305_off + substr $S10, rx1305_tgt, $I11, 4 + ne $S10, "redo", rx1305_fail + add rx1305_pos, 4 + set_addr $I10, rxcap_1309_fail + ($I12, $I11) = rx1305_cur."!mark_peek"($I10) + rx1305_cur."!cursor_pos"($I11) + ($P10) = rx1305_cur."!cursor_start"() + $P10."!cursor_pass"(rx1305_pos, "") + rx1305_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("sym") + goto rxcap_1309_done + rxcap_1309_fail: + goto rx1305_fail + rxcap_1309_done: # rx pass - rx1317_cur."!cursor_pass"(rx1317_pos, "") - rx1317_cur."!cursor_debug"("PASS ", "", " at pos=", rx1317_pos) - .return (rx1317_cur) - rx1317_fail: - (rx1317_rep, rx1317_pos, $I10, $P10) = rx1317_cur."!mark_fail"(0) - lt rx1317_pos, -1, rx1317_done - eq rx1317_pos, -1, rx1317_fail + rx1305_cur."!cursor_pass"(rx1305_pos, "term:sym") + rx1305_cur."!cursor_debug"("PASS ", "term:sym", " at pos=", rx1305_pos) + .return (rx1305_cur) + rx1305_fail: +.annotate 'line', 445 + (rx1305_rep, rx1305_pos, $I10, $P10) = rx1305_cur."!mark_fail"(0) + lt rx1305_pos, -1, rx1305_done + eq rx1305_pos, -1, rx1305_fail jump $I10 - rx1317_done: - rx1317_cur."!cursor_fail"() - rx1317_cur."!cursor_debug"("FAIL ", "") - .return (rx1317_cur) + rx1305_done: + rx1305_cur."!cursor_fail"() + rx1305_cur."!cursor_debug"("FAIL ", "term:sym") + .return (rx1305_cur) .return () .end -.namespace ["NQP";"Regex"] -.sub "assertion:sym<{ }>" :subid("341_1275511697.61926") :method :outer("332_1275511697.61926") -.annotate 'line', 550 - .local string rx1320_tgt - .local int rx1320_pos - .local int rx1320_off - .local int rx1320_eos - .local int rx1320_rep - .local pmc rx1320_cur - (rx1320_cur, rx1320_pos, rx1320_tgt) = self."!cursor_start"() - rx1320_cur."!cursor_debug"("START ", "assertion:sym<{ }>") - .lex unicode:"$\x{a2}", rx1320_cur - .local pmc match - .lex "$/", match - length rx1320_eos, rx1320_tgt - gt rx1320_pos, rx1320_eos, rx1320_done - set rx1320_off, 0 - lt rx1320_pos, 2, rx1320_start - sub rx1320_off, rx1320_pos, 1 - substr rx1320_tgt, rx1320_tgt, rx1320_off - rx1320_start: - $I10 = self.'from'() - ne $I10, -1, rxscan1323_done - goto rxscan1323_scan - rxscan1323_loop: - ($P10) = rx1320_cur."from"() - inc $P10 - set rx1320_pos, $P10 - ge rx1320_pos, rx1320_eos, rxscan1323_done - rxscan1323_scan: - set_addr $I10, rxscan1323_loop - rx1320_cur."!mark_push"(0, rx1320_pos, $I10) - rxscan1323_done: -.annotate 'line', 564 - # rx enumcharlist negate=0 zerowidth - ge rx1320_pos, rx1320_eos, rx1320_fail - sub $I10, rx1320_pos, rx1320_off - substr $S10, rx1320_tgt, $I10, 1 - index $I11, "{", $S10 - lt $I11, 0, rx1320_fail - # rx subrule "codeblock" subtype=capture negate= - rx1320_cur."!cursor_pos"(rx1320_pos) - $P10 = rx1320_cur."codeblock"() - unless $P10, rx1320_fail - rx1320_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("codeblock") - rx1320_pos = $P10."pos"() -.annotate 'line', 563 - # rx pass - rx1320_cur."!cursor_pass"(rx1320_pos, "assertion:sym<{ }>") - rx1320_cur."!cursor_debug"("PASS ", "assertion:sym<{ }>", " at pos=", rx1320_pos) - .return (rx1320_cur) - rx1320_fail: -.annotate 'line', 550 - (rx1320_rep, rx1320_pos, $I10, $P10) = rx1320_cur."!mark_fail"(0) - lt rx1320_pos, -1, rx1320_done - eq rx1320_pos, -1, rx1320_fail - jump $I10 - rx1320_done: - rx1320_cur."!cursor_fail"() - rx1320_cur."!cursor_debug"("FAIL ", "assertion:sym<{ }>") - .return (rx1320_cur) - .return () +.namespace ["NQP";"Grammar"] +.sub "!PREFIX__term:sym" :subid("339_1275600007.84296") :method +.annotate 'line', 445 + new $P1307, "ResizablePMCArray" + push $P1307, "redo" + .return ($P1307) .end -.namespace ["NQP";"Regex"] -.sub "!PREFIX__assertion:sym<{ }>" :subid("342_1275511697.61926") :method -.annotate 'line', 550 - new $P1322, "ResizablePMCArray" - push $P1322, "{" +.namespace ["NQP";"Grammar"] +.sub "smartmatch" :subid("340_1275600007.84296") :method :outer("11_1275600007.84296") + .param pmc param_1313 +.annotate 'line', 556 + new $P1312, 'ExceptionHandler' + set_addr $P1312, control_1311 + $P1312."handle_types"(57) + push_eh $P1312 + .lex "self", self + .lex "$/", param_1313 +.annotate 'line', 558 + new $P1314, "Undef" + .lex "$t", $P1314 + find_lex $P1315, "$/" + unless_null $P1315, vivify_376 + $P1315 = root_new ['parrot';'ResizablePMCArray'] + vivify_376: + set $P1316, $P1315[0] + unless_null $P1316, vivify_377 + new $P1316, "Undef" + vivify_377: + store_lex "$t", $P1316 + find_lex $P1317, "$/" + unless_null $P1317, vivify_378 + $P1317 = root_new ['parrot';'ResizablePMCArray'] + vivify_378: + set $P1318, $P1317[1] + unless_null $P1318, vivify_379 + new $P1318, "Undef" + vivify_379: + find_lex $P1319, "$/" + unless_null $P1319, vivify_380 + $P1319 = root_new ['parrot';'ResizablePMCArray'] + store_lex "$/", $P1319 + vivify_380: + set $P1319[0], $P1318 + find_lex $P1320, "$t" + find_lex $P1321, "$/" + unless_null $P1321, vivify_381 + $P1321 = root_new ['parrot';'ResizablePMCArray'] + store_lex "$/", $P1321 + vivify_381: + set $P1321[1], $P1320 +.annotate 'line', 556 + .return ($P1320) + control_1311: + .local pmc exception + .get_results (exception) + getattribute $P1322, exception, "payload" .return ($P1322) .end .namespace ["NQP";"Regex"] -.sub "assertion:sym" :subid("343_1275511697.61926") :method :outer("332_1275511697.61926") -.annotate 'line', 550 - .const 'Sub' $P1330 = "345_1275511697.61926" - capture_lex $P1330 - .local string rx1325_tgt - .local int rx1325_pos - .local int rx1325_off - .local int rx1325_eos - .local int rx1325_rep - .local pmc rx1325_cur - (rx1325_cur, rx1325_pos, rx1325_tgt) = self."!cursor_start"() - rx1325_cur."!cursor_debug"("START ", "assertion:sym") - .lex unicode:"$\x{a2}", rx1325_cur +.sub "_block1323" :subid("341_1275600007.84296") :outer("11_1275600007.84296") +.annotate 'line', 562 + .const 'Sub' $P1381 = "360_1275600007.84296" + capture_lex $P1381 + .const 'Sub' $P1376 = "358_1275600007.84296" + capture_lex $P1376 + .const 'Sub' $P1363 = "355_1275600007.84296" + capture_lex $P1363 + .const 'Sub' $P1353 = "352_1275600007.84296" + capture_lex $P1353 + .const 'Sub' $P1348 = "350_1275600007.84296" + capture_lex $P1348 + .const 'Sub' $P1339 = "347_1275600007.84296" + capture_lex $P1339 + .const 'Sub' $P1334 = "345_1275600007.84296" + capture_lex $P1334 + .const 'Sub' $P1325 = "342_1275600007.84296" + capture_lex $P1325 + .const 'Sub' $P1381 = "360_1275600007.84296" + capture_lex $P1381 + .return ($P1381) +.end + + +.namespace ["NQP";"Regex"] +.sub "metachar:sym<:my>" :subid("342_1275600007.84296") :method :outer("341_1275600007.84296") +.annotate 'line', 562 + .const 'Sub' $P1331 = "344_1275600007.84296" + capture_lex $P1331 + .local string rx1326_tgt + .local int rx1326_pos + .local int rx1326_off + .local int rx1326_eos + .local int rx1326_rep + .local pmc rx1326_cur + (rx1326_cur, rx1326_pos, rx1326_tgt) = self."!cursor_start"() + rx1326_cur."!cursor_debug"("START ", "metachar:sym<:my>") + .lex unicode:"$\x{a2}", rx1326_cur .local pmc match .lex "$/", match - length rx1325_eos, rx1325_tgt - gt rx1325_pos, rx1325_eos, rx1325_done - set rx1325_off, 0 - lt rx1325_pos, 2, rx1325_start - sub rx1325_off, rx1325_pos, 1 - substr rx1325_tgt, rx1325_tgt, rx1325_off - rx1325_start: + length rx1326_eos, rx1326_tgt + gt rx1326_pos, rx1326_eos, rx1326_done + set rx1326_off, 0 + lt rx1326_pos, 2, rx1326_start + sub rx1326_off, rx1326_pos, 1 + substr rx1326_tgt, rx1326_tgt, rx1326_off + rx1326_start: $I10 = self.'from'() - ne $I10, -1, rxscan1328_done - goto rxscan1328_scan - rxscan1328_loop: - ($P10) = rx1325_cur."from"() + ne $I10, -1, rxscan1329_done + goto rxscan1329_scan + rxscan1329_loop: + ($P10) = rx1326_cur."from"() inc $P10 - set rx1325_pos, $P10 - ge rx1325_pos, rx1325_eos, rxscan1328_done - rxscan1328_scan: - set_addr $I10, rxscan1328_loop - rx1325_cur."!mark_push"(0, rx1325_pos, $I10) - rxscan1328_done: -.annotate 'line', 568 - # rx subcapture "zw" - set_addr $I10, rxcap_1333_fail - rx1325_cur."!mark_push"(0, rx1325_pos, $I10) - # rx enumcharlist negate=0 - ge rx1325_pos, rx1325_eos, rx1325_fail - sub $I10, rx1325_pos, rx1325_off - substr $S10, rx1325_tgt, $I10, 1 - index $I11, "?!", $S10 - lt $I11, 0, rx1325_fail - inc rx1325_pos + set rx1326_pos, $P10 + ge rx1326_pos, rx1326_eos, rxscan1329_done + rxscan1329_scan: + set_addr $I10, rxscan1329_loop + rx1326_cur."!mark_push"(0, rx1326_pos, $I10) + rxscan1329_done: +.annotate 'line', 564 + # rx literal ":" + add $I11, rx1326_pos, 1 + gt $I11, rx1326_eos, rx1326_fail + sub $I11, rx1326_pos, rx1326_off + substr $S10, rx1326_tgt, $I11, 1 + ne $S10, ":", rx1326_fail + add rx1326_pos, 1 # rx subrule "before" subtype=zerowidth negate= - rx1325_cur."!cursor_pos"(rx1325_pos) - .const 'Sub' $P1330 = "345_1275511697.61926" - capture_lex $P1330 - $P10 = rx1325_cur."before"($P1330) - unless $P10, rx1325_fail - set_addr $I10, rxcap_1333_fail - ($I12, $I11) = rx1325_cur."!mark_peek"($I10) - rx1325_cur."!cursor_pos"($I11) - ($P10) = rx1325_cur."!cursor_start"() - $P10."!cursor_pass"(rx1325_pos, "") - rx1325_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("zw") - goto rxcap_1333_done - rxcap_1333_fail: - goto rx1325_fail - rxcap_1333_done: - # rx subrule "codeblock" subtype=capture negate= - rx1325_cur."!cursor_pos"(rx1325_pos) - $P10 = rx1325_cur."codeblock"() - unless $P10, rx1325_fail - rx1325_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("codeblock") - rx1325_pos = $P10."pos"() -.annotate 'line', 567 + rx1326_cur."!cursor_pos"(rx1326_pos) + .const 'Sub' $P1331 = "344_1275600007.84296" + capture_lex $P1331 + $P10 = rx1326_cur."before"($P1331) + unless $P10, rx1326_fail + # rx subrule "LANG" subtype=capture negate= + rx1326_cur."!cursor_pos"(rx1326_pos) + $P10 = rx1326_cur."LANG"("MAIN", "statement") + unless $P10, rx1326_fail + rx1326_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("statement") + rx1326_pos = $P10."pos"() + # rx subrule "ws" subtype=method negate= + rx1326_cur."!cursor_pos"(rx1326_pos) + $P10 = rx1326_cur."ws"() + unless $P10, rx1326_fail + rx1326_pos = $P10."pos"() + # rx literal ";" + add $I11, rx1326_pos, 1 + gt $I11, rx1326_eos, rx1326_fail + sub $I11, rx1326_pos, rx1326_off + substr $S10, rx1326_tgt, $I11, 1 + ne $S10, ";", rx1326_fail + add rx1326_pos, 1 +.annotate 'line', 563 # rx pass - rx1325_cur."!cursor_pass"(rx1325_pos, "assertion:sym") - rx1325_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx1325_pos) - .return (rx1325_cur) - rx1325_fail: -.annotate 'line', 550 - (rx1325_rep, rx1325_pos, $I10, $P10) = rx1325_cur."!mark_fail"(0) - lt rx1325_pos, -1, rx1325_done - eq rx1325_pos, -1, rx1325_fail + rx1326_cur."!cursor_pass"(rx1326_pos, "metachar:sym<:my>") + rx1326_cur."!cursor_debug"("PASS ", "metachar:sym<:my>", " at pos=", rx1326_pos) + .return (rx1326_cur) + rx1326_fail: +.annotate 'line', 562 + (rx1326_rep, rx1326_pos, $I10, $P10) = rx1326_cur."!mark_fail"(0) + lt rx1326_pos, -1, rx1326_done + eq rx1326_pos, -1, rx1326_fail jump $I10 - rx1325_done: - rx1325_cur."!cursor_fail"() - rx1325_cur."!cursor_debug"("FAIL ", "assertion:sym") - .return (rx1325_cur) + rx1326_done: + rx1326_cur."!cursor_fail"() + rx1326_cur."!cursor_debug"("FAIL ", "metachar:sym<:my>") + .return (rx1326_cur) .return () .end .namespace ["NQP";"Regex"] -.sub "!PREFIX__assertion:sym" :subid("344_1275511697.61926") :method -.annotate 'line', 550 - new $P1327, "ResizablePMCArray" - push $P1327, "!" - push $P1327, "?" - .return ($P1327) +.sub "!PREFIX__metachar:sym<:my>" :subid("343_1275600007.84296") :method +.annotate 'line', 562 + new $P1328, "ResizablePMCArray" + push $P1328, ":" + .return ($P1328) .end .namespace ["NQP";"Regex"] -.sub "_block1329" :anon :subid("345_1275511697.61926") :method :outer("343_1275511697.61926") -.annotate 'line', 568 - .local string rx1331_tgt - .local int rx1331_pos - .local int rx1331_off - .local int rx1331_eos - .local int rx1331_rep - .local pmc rx1331_cur - (rx1331_cur, rx1331_pos, rx1331_tgt) = self."!cursor_start"() - rx1331_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx1331_cur +.sub "_block1330" :anon :subid("344_1275600007.84296") :method :outer("342_1275600007.84296") +.annotate 'line', 564 + .local string rx1332_tgt + .local int rx1332_pos + .local int rx1332_off + .local int rx1332_eos + .local int rx1332_rep + .local pmc rx1332_cur + (rx1332_cur, rx1332_pos, rx1332_tgt) = self."!cursor_start"() + rx1332_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx1332_cur .local pmc match .lex "$/", match - length rx1331_eos, rx1331_tgt - gt rx1331_pos, rx1331_eos, rx1331_done - set rx1331_off, 0 - lt rx1331_pos, 2, rx1331_start - sub rx1331_off, rx1331_pos, 1 - substr rx1331_tgt, rx1331_tgt, rx1331_off - rx1331_start: + length rx1332_eos, rx1332_tgt + gt rx1332_pos, rx1332_eos, rx1332_done + set rx1332_off, 0 + lt rx1332_pos, 2, rx1332_start + sub rx1332_off, rx1332_pos, 1 + substr rx1332_tgt, rx1332_tgt, rx1332_off + rx1332_start: $I10 = self.'from'() - ne $I10, -1, rxscan1332_done - goto rxscan1332_scan - rxscan1332_loop: - ($P10) = rx1331_cur."from"() + ne $I10, -1, rxscan1333_done + goto rxscan1333_scan + rxscan1333_loop: + ($P10) = rx1332_cur."from"() inc $P10 - set rx1331_pos, $P10 - ge rx1331_pos, rx1331_eos, rxscan1332_done - rxscan1332_scan: - set_addr $I10, rxscan1332_loop - rx1331_cur."!mark_push"(0, rx1331_pos, $I10) - rxscan1332_done: - # rx literal "{" - add $I11, rx1331_pos, 1 - gt $I11, rx1331_eos, rx1331_fail - sub $I11, rx1331_pos, rx1331_off - substr $S10, rx1331_tgt, $I11, 1 - ne $S10, "{", rx1331_fail - add rx1331_pos, 1 + set rx1332_pos, $P10 + ge rx1332_pos, rx1332_eos, rxscan1333_done + rxscan1333_scan: + set_addr $I10, rxscan1333_loop + rx1332_cur."!mark_push"(0, rx1332_pos, $I10) + rxscan1333_done: + # rx literal "my" + add $I11, rx1332_pos, 2 + gt $I11, rx1332_eos, rx1332_fail + sub $I11, rx1332_pos, rx1332_off + substr $S10, rx1332_tgt, $I11, 2 + ne $S10, "my", rx1332_fail + add rx1332_pos, 2 # rx pass - rx1331_cur."!cursor_pass"(rx1331_pos, "") - rx1331_cur."!cursor_debug"("PASS ", "", " at pos=", rx1331_pos) - .return (rx1331_cur) - rx1331_fail: - (rx1331_rep, rx1331_pos, $I10, $P10) = rx1331_cur."!mark_fail"(0) - lt rx1331_pos, -1, rx1331_done - eq rx1331_pos, -1, rx1331_fail + rx1332_cur."!cursor_pass"(rx1332_pos, "") + rx1332_cur."!cursor_debug"("PASS ", "", " at pos=", rx1332_pos) + .return (rx1332_cur) + rx1332_fail: + (rx1332_rep, rx1332_pos, $I10, $P10) = rx1332_cur."!mark_fail"(0) + lt rx1332_pos, -1, rx1332_done + eq rx1332_pos, -1, rx1332_fail jump $I10 - rx1331_done: - rx1331_cur."!cursor_fail"() - rx1331_cur."!cursor_debug"("FAIL ", "") - .return (rx1331_cur) + rx1332_done: + rx1332_cur."!cursor_fail"() + rx1332_cur."!cursor_debug"("FAIL ", "") + .return (rx1332_cur) .return () .end .namespace ["NQP";"Regex"] -.sub "assertion:sym" :subid("346_1275511697.61926") :method :outer("332_1275511697.61926") -.annotate 'line', 550 - .const 'Sub' $P1343 = "348_1275511697.61926" - capture_lex $P1343 +.sub "metachar:sym<{ }>" :subid("345_1275600007.84296") :method :outer("341_1275600007.84296") +.annotate 'line', 562 .local string rx1335_tgt .local int rx1335_pos .local int rx1335_off @@ -16652,8 +16569,7 @@ NQP::Compiler - NQP compiler .local int rx1335_rep .local pmc rx1335_cur (rx1335_cur, rx1335_pos, rx1335_tgt) = self."!cursor_start"() - rx1335_cur."!cursor_debug"("START ", "assertion:sym") - rx1335_cur."!cursor_caparray"("arglist", "nibbler", "assertion") + rx1335_cur."!cursor_debug"("START ", "metachar:sym<{ }>") .lex unicode:"$\x{a2}", rx1335_cur .local pmc match .lex "$/", match @@ -16676,378 +16592,830 @@ NQP::Compiler - NQP compiler set_addr $I10, rxscan1338_loop rx1335_cur."!mark_push"(0, rx1335_pos, $I10) rxscan1338_done: -.annotate 'line', 572 - # rx subcapture "longname" - set_addr $I10, rxcap_1339_fail - rx1335_cur."!mark_push"(0, rx1335_pos, $I10) - # rx charclass_q w r 1..-1 +.annotate 'line', 568 + # rx enumcharlist negate=0 zerowidth + ge rx1335_pos, rx1335_eos, rx1335_fail sub $I10, rx1335_pos, rx1335_off - find_not_cclass $I11, 8192, rx1335_tgt, $I10, rx1335_eos - add $I12, $I10, 1 - lt $I11, $I12, rx1335_fail - add rx1335_pos, rx1335_off, $I11 - set_addr $I10, rxcap_1339_fail - ($I12, $I11) = rx1335_cur."!mark_peek"($I10) - rx1335_cur."!cursor_pos"($I11) - ($P10) = rx1335_cur."!cursor_start"() - $P10."!cursor_pass"(rx1335_pos, "") - rx1335_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("longname") - goto rxcap_1339_done - rxcap_1339_fail: - goto rx1335_fail - rxcap_1339_done: -.annotate 'line', 579 - # rx rxquantr1340 ** 0..1 - set_addr $I1346, rxquantr1340_done - rx1335_cur."!mark_push"(0, rx1335_pos, $I1346) - rxquantr1340_loop: - alt1341_0: -.annotate 'line', 573 - set_addr $I10, alt1341_1 - rx1335_cur."!mark_push"(0, rx1335_pos, $I10) -.annotate 'line', 574 - # rx subrule "before" subtype=zerowidth negate= - rx1335_cur."!cursor_pos"(rx1335_pos) - .const 'Sub' $P1343 = "348_1275511697.61926" - capture_lex $P1343 - $P10 = rx1335_cur."before"($P1343) - unless $P10, rx1335_fail - goto alt1341_end - alt1341_1: - set_addr $I10, alt1341_2 - rx1335_cur."!mark_push"(0, rx1335_pos, $I10) -.annotate 'line', 575 - # rx literal "=" - add $I11, rx1335_pos, 1 - gt $I11, rx1335_eos, rx1335_fail - sub $I11, rx1335_pos, rx1335_off - substr $S10, rx1335_tgt, $I11, 1 - ne $S10, "=", rx1335_fail - add rx1335_pos, 1 - # rx subrule "assertion" subtype=capture negate= - rx1335_cur."!cursor_pos"(rx1335_pos) - $P10 = rx1335_cur."assertion"() - unless $P10, rx1335_fail - rx1335_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("assertion") - rx1335_pos = $P10."pos"() - goto alt1341_end - alt1341_2: - set_addr $I10, alt1341_3 - rx1335_cur."!mark_push"(0, rx1335_pos, $I10) -.annotate 'line', 576 - # rx literal ":" - add $I11, rx1335_pos, 1 - gt $I11, rx1335_eos, rx1335_fail - sub $I11, rx1335_pos, rx1335_off - substr $S10, rx1335_tgt, $I11, 1 - ne $S10, ":", rx1335_fail - add rx1335_pos, 1 - # rx subrule "arglist" subtype=capture negate= - rx1335_cur."!cursor_pos"(rx1335_pos) - $P10 = rx1335_cur."arglist"() - unless $P10, rx1335_fail - rx1335_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("arglist") - rx1335_pos = $P10."pos"() - goto alt1341_end - alt1341_3: - set_addr $I10, alt1341_4 - rx1335_cur."!mark_push"(0, rx1335_pos, $I10) -.annotate 'line', 577 - # rx literal "(" - add $I11, rx1335_pos, 1 - gt $I11, rx1335_eos, rx1335_fail - sub $I11, rx1335_pos, rx1335_off - substr $S10, rx1335_tgt, $I11, 1 - ne $S10, "(", rx1335_fail - add rx1335_pos, 1 - # rx subrule "LANG" subtype=capture negate= + substr $S10, rx1335_tgt, $I10, 1 + index $I11, "{", $S10 + lt $I11, 0, rx1335_fail + # rx subrule "codeblock" subtype=capture negate= rx1335_cur."!cursor_pos"(rx1335_pos) - $P10 = rx1335_cur."LANG"("MAIN", "arglist") + $P10 = rx1335_cur."codeblock"() unless $P10, rx1335_fail rx1335_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("arglist") + $P10."!cursor_names"("codeblock") rx1335_pos = $P10."pos"() - # rx literal ")" - add $I11, rx1335_pos, 1 - gt $I11, rx1335_eos, rx1335_fail - sub $I11, rx1335_pos, rx1335_off - substr $S10, rx1335_tgt, $I11, 1 - ne $S10, ")", rx1335_fail - add rx1335_pos, 1 - goto alt1341_end - alt1341_4: -.annotate 'line', 578 - # rx subrule "normspace" subtype=method negate= - rx1335_cur."!cursor_pos"(rx1335_pos) - $P10 = rx1335_cur."normspace"() - unless $P10, rx1335_fail - rx1335_pos = $P10."pos"() - # rx subrule "nibbler" subtype=capture negate= - rx1335_cur."!cursor_pos"(rx1335_pos) - $P10 = rx1335_cur."nibbler"() - unless $P10, rx1335_fail - rx1335_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("nibbler") - rx1335_pos = $P10."pos"() - alt1341_end: -.annotate 'line', 579 - (rx1335_rep) = rx1335_cur."!mark_commit"($I1346) - rxquantr1340_done: -.annotate 'line', 571 +.annotate 'line', 567 # rx pass - rx1335_cur."!cursor_pass"(rx1335_pos, "assertion:sym") - rx1335_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx1335_pos) + rx1335_cur."!cursor_pass"(rx1335_pos, "metachar:sym<{ }>") + rx1335_cur."!cursor_debug"("PASS ", "metachar:sym<{ }>", " at pos=", rx1335_pos) .return (rx1335_cur) rx1335_fail: -.annotate 'line', 550 +.annotate 'line', 562 (rx1335_rep, rx1335_pos, $I10, $P10) = rx1335_cur."!mark_fail"(0) lt rx1335_pos, -1, rx1335_done eq rx1335_pos, -1, rx1335_fail jump $I10 rx1335_done: rx1335_cur."!cursor_fail"() - rx1335_cur."!cursor_debug"("FAIL ", "assertion:sym") + rx1335_cur."!cursor_debug"("FAIL ", "metachar:sym<{ }>") .return (rx1335_cur) .return () .end .namespace ["NQP";"Regex"] -.sub "!PREFIX__assertion:sym" :subid("347_1275511697.61926") :method -.annotate 'line', 550 +.sub "!PREFIX__metachar:sym<{ }>" :subid("346_1275600007.84296") :method +.annotate 'line', 562 new $P1337, "ResizablePMCArray" - push $P1337, "" + push $P1337, "{" .return ($P1337) .end .namespace ["NQP";"Regex"] -.sub "_block1342" :anon :subid("348_1275511697.61926") :method :outer("346_1275511697.61926") -.annotate 'line', 574 - .local string rx1344_tgt - .local int rx1344_pos - .local int rx1344_off - .local int rx1344_eos - .local int rx1344_rep - .local pmc rx1344_cur - (rx1344_cur, rx1344_pos, rx1344_tgt) = self."!cursor_start"() - rx1344_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx1344_cur +.sub "metachar:sym" :subid("347_1275600007.84296") :method :outer("341_1275600007.84296") +.annotate 'line', 562 + .const 'Sub' $P1345 = "349_1275600007.84296" + capture_lex $P1345 + .local string rx1340_tgt + .local int rx1340_pos + .local int rx1340_off + .local int rx1340_eos + .local int rx1340_rep + .local pmc rx1340_cur + (rx1340_cur, rx1340_pos, rx1340_tgt) = self."!cursor_start"() + rx1340_cur."!cursor_debug"("START ", "metachar:sym") + .lex unicode:"$\x{a2}", rx1340_cur .local pmc match .lex "$/", match - length rx1344_eos, rx1344_tgt - gt rx1344_pos, rx1344_eos, rx1344_done - set rx1344_off, 0 - lt rx1344_pos, 2, rx1344_start - sub rx1344_off, rx1344_pos, 1 - substr rx1344_tgt, rx1344_tgt, rx1344_off - rx1344_start: + length rx1340_eos, rx1340_tgt + gt rx1340_pos, rx1340_eos, rx1340_done + set rx1340_off, 0 + lt rx1340_pos, 2, rx1340_start + sub rx1340_off, rx1340_pos, 1 + substr rx1340_tgt, rx1340_tgt, rx1340_off + rx1340_start: $I10 = self.'from'() - ne $I10, -1, rxscan1345_done - goto rxscan1345_scan - rxscan1345_loop: - ($P10) = rx1344_cur."from"() + ne $I10, -1, rxscan1343_done + goto rxscan1343_scan + rxscan1343_loop: + ($P10) = rx1340_cur."from"() inc $P10 - set rx1344_pos, $P10 - ge rx1344_pos, rx1344_eos, rxscan1345_done - rxscan1345_scan: - set_addr $I10, rxscan1345_loop - rx1344_cur."!mark_push"(0, rx1344_pos, $I10) - rxscan1345_done: - # rx literal ">" - add $I11, rx1344_pos, 1 - gt $I11, rx1344_eos, rx1344_fail - sub $I11, rx1344_pos, rx1344_off - substr $S10, rx1344_tgt, $I11, 1 - ne $S10, ">", rx1344_fail - add rx1344_pos, 1 + set rx1340_pos, $P10 + ge rx1340_pos, rx1340_eos, rxscan1343_done + rxscan1343_scan: + set_addr $I10, rxscan1343_loop + rx1340_cur."!mark_push"(0, rx1340_pos, $I10) + rxscan1343_done: +.annotate 'line', 572 + # rx enumcharlist negate=0 zerowidth + ge rx1340_pos, rx1340_eos, rx1340_fail + sub $I10, rx1340_pos, rx1340_off + substr $S10, rx1340_tgt, $I10, 1 + index $I11, "$@", $S10 + lt $I11, 0, rx1340_fail + # rx subrule "before" subtype=zerowidth negate= + rx1340_cur."!cursor_pos"(rx1340_pos) + .const 'Sub' $P1345 = "349_1275600007.84296" + capture_lex $P1345 + $P10 = rx1340_cur."before"($P1345) + unless $P10, rx1340_fail + # rx subrule "LANG" subtype=capture negate= + rx1340_cur."!cursor_pos"(rx1340_pos) + $P10 = rx1340_cur."LANG"("MAIN", "variable") + unless $P10, rx1340_fail + rx1340_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("var") + rx1340_pos = $P10."pos"() +.annotate 'line', 571 # rx pass - rx1344_cur."!cursor_pass"(rx1344_pos, "") - rx1344_cur."!cursor_debug"("PASS ", "", " at pos=", rx1344_pos) - .return (rx1344_cur) - rx1344_fail: - (rx1344_rep, rx1344_pos, $I10, $P10) = rx1344_cur."!mark_fail"(0) - lt rx1344_pos, -1, rx1344_done - eq rx1344_pos, -1, rx1344_fail + rx1340_cur."!cursor_pass"(rx1340_pos, "metachar:sym") + rx1340_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx1340_pos) + .return (rx1340_cur) + rx1340_fail: +.annotate 'line', 562 + (rx1340_rep, rx1340_pos, $I10, $P10) = rx1340_cur."!mark_fail"(0) + lt rx1340_pos, -1, rx1340_done + eq rx1340_pos, -1, rx1340_fail jump $I10 - rx1344_done: - rx1344_cur."!cursor_fail"() - rx1344_cur."!cursor_debug"("FAIL ", "") - .return (rx1344_cur) + rx1340_done: + rx1340_cur."!cursor_fail"() + rx1340_cur."!cursor_debug"("FAIL ", "metachar:sym") + .return (rx1340_cur) .return () .end .namespace ["NQP";"Regex"] -.sub "assertion:sym" :subid("349_1275511697.61926") :method :outer("332_1275511697.61926") -.annotate 'line', 550 - .local string rx1348_tgt - .local int rx1348_pos - .local int rx1348_off - .local int rx1348_eos - .local int rx1348_rep - .local pmc rx1348_cur - (rx1348_cur, rx1348_pos, rx1348_tgt) = self."!cursor_start"() - rx1348_cur."!cursor_debug"("START ", "assertion:sym") - .lex unicode:"$\x{a2}", rx1348_cur +.sub "!PREFIX__metachar:sym" :subid("348_1275600007.84296") :method +.annotate 'line', 562 + new $P1342, "ResizablePMCArray" + push $P1342, "$" + push $P1342, "@" + .return ($P1342) +.end + + +.namespace ["NQP";"Regex"] +.sub "_block1344" :anon :subid("349_1275600007.84296") :method :outer("347_1275600007.84296") +.annotate 'line', 572 + .local string rx1346_tgt + .local int rx1346_pos + .local int rx1346_off + .local int rx1346_eos + .local int rx1346_rep + .local pmc rx1346_cur + (rx1346_cur, rx1346_pos, rx1346_tgt) = self."!cursor_start"() + rx1346_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx1346_cur .local pmc match .lex "$/", match - length rx1348_eos, rx1348_tgt - gt rx1348_pos, rx1348_eos, rx1348_done - set rx1348_off, 0 - lt rx1348_pos, 2, rx1348_start - sub rx1348_off, rx1348_pos, 1 - substr rx1348_tgt, rx1348_tgt, rx1348_off - rx1348_start: + length rx1346_eos, rx1346_tgt + gt rx1346_pos, rx1346_eos, rx1346_done + set rx1346_off, 0 + lt rx1346_pos, 2, rx1346_start + sub rx1346_off, rx1346_pos, 1 + substr rx1346_tgt, rx1346_tgt, rx1346_off + rx1346_start: $I10 = self.'from'() - ne $I10, -1, rxscan1351_done - goto rxscan1351_scan - rxscan1351_loop: - ($P10) = rx1348_cur."from"() + ne $I10, -1, rxscan1347_done + goto rxscan1347_scan + rxscan1347_loop: + ($P10) = rx1346_cur."from"() inc $P10 - set rx1348_pos, $P10 - ge rx1348_pos, rx1348_eos, rxscan1351_done - rxscan1351_scan: - set_addr $I10, rxscan1351_loop - rx1348_cur."!mark_push"(0, rx1348_pos, $I10) - rxscan1351_done: -.annotate 'line', 583 + set rx1346_pos, $P10 + ge rx1346_pos, rx1346_eos, rxscan1347_done + rxscan1347_scan: + set_addr $I10, rxscan1347_loop + rx1346_cur."!mark_push"(0, rx1346_pos, $I10) + rxscan1347_done: + # rx charclass . + ge rx1346_pos, rx1346_eos, rx1346_fail + inc rx1346_pos + # rx charclass w + ge rx1346_pos, rx1346_eos, rx1346_fail + sub $I10, rx1346_pos, rx1346_off + is_cclass $I11, 8192, rx1346_tgt, $I10 + unless $I11, rx1346_fail + inc rx1346_pos + # rx pass + rx1346_cur."!cursor_pass"(rx1346_pos, "") + rx1346_cur."!cursor_debug"("PASS ", "", " at pos=", rx1346_pos) + .return (rx1346_cur) + rx1346_fail: + (rx1346_rep, rx1346_pos, $I10, $P10) = rx1346_cur."!mark_fail"(0) + lt rx1346_pos, -1, rx1346_done + eq rx1346_pos, -1, rx1346_fail + jump $I10 + rx1346_done: + rx1346_cur."!cursor_fail"() + rx1346_cur."!cursor_debug"("FAIL ", "") + .return (rx1346_cur) + .return () +.end + + +.namespace ["NQP";"Regex"] +.sub "assertion:sym<{ }>" :subid("350_1275600007.84296") :method :outer("341_1275600007.84296") +.annotate 'line', 562 + .local string rx1349_tgt + .local int rx1349_pos + .local int rx1349_off + .local int rx1349_eos + .local int rx1349_rep + .local pmc rx1349_cur + (rx1349_cur, rx1349_pos, rx1349_tgt) = self."!cursor_start"() + rx1349_cur."!cursor_debug"("START ", "assertion:sym<{ }>") + .lex unicode:"$\x{a2}", rx1349_cur + .local pmc match + .lex "$/", match + length rx1349_eos, rx1349_tgt + gt rx1349_pos, rx1349_eos, rx1349_done + set rx1349_off, 0 + lt rx1349_pos, 2, rx1349_start + sub rx1349_off, rx1349_pos, 1 + substr rx1349_tgt, rx1349_tgt, rx1349_off + rx1349_start: + $I10 = self.'from'() + ne $I10, -1, rxscan1352_done + goto rxscan1352_scan + rxscan1352_loop: + ($P10) = rx1349_cur."from"() + inc $P10 + set rx1349_pos, $P10 + ge rx1349_pos, rx1349_eos, rxscan1352_done + rxscan1352_scan: + set_addr $I10, rxscan1352_loop + rx1349_cur."!mark_push"(0, rx1349_pos, $I10) + rxscan1352_done: +.annotate 'line', 576 # rx enumcharlist negate=0 zerowidth - ge rx1348_pos, rx1348_eos, rx1348_fail - sub $I10, rx1348_pos, rx1348_off - substr $S10, rx1348_tgt, $I10, 1 - index $I11, "$@", $S10 - lt $I11, 0, rx1348_fail - # rx subrule "LANG" subtype=capture negate= - rx1348_cur."!cursor_pos"(rx1348_pos) - $P10 = rx1348_cur."LANG"("MAIN", "variable") - unless $P10, rx1348_fail - rx1348_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("var") - rx1348_pos = $P10."pos"() -.annotate 'line', 582 + ge rx1349_pos, rx1349_eos, rx1349_fail + sub $I10, rx1349_pos, rx1349_off + substr $S10, rx1349_tgt, $I10, 1 + index $I11, "{", $S10 + lt $I11, 0, rx1349_fail + # rx subrule "codeblock" subtype=capture negate= + rx1349_cur."!cursor_pos"(rx1349_pos) + $P10 = rx1349_cur."codeblock"() + unless $P10, rx1349_fail + rx1349_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("codeblock") + rx1349_pos = $P10."pos"() +.annotate 'line', 575 # rx pass - rx1348_cur."!cursor_pass"(rx1348_pos, "assertion:sym") - rx1348_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx1348_pos) - .return (rx1348_cur) - rx1348_fail: -.annotate 'line', 550 - (rx1348_rep, rx1348_pos, $I10, $P10) = rx1348_cur."!mark_fail"(0) - lt rx1348_pos, -1, rx1348_done - eq rx1348_pos, -1, rx1348_fail + rx1349_cur."!cursor_pass"(rx1349_pos, "assertion:sym<{ }>") + rx1349_cur."!cursor_debug"("PASS ", "assertion:sym<{ }>", " at pos=", rx1349_pos) + .return (rx1349_cur) + rx1349_fail: +.annotate 'line', 562 + (rx1349_rep, rx1349_pos, $I10, $P10) = rx1349_cur."!mark_fail"(0) + lt rx1349_pos, -1, rx1349_done + eq rx1349_pos, -1, rx1349_fail jump $I10 - rx1348_done: - rx1348_cur."!cursor_fail"() - rx1348_cur."!cursor_debug"("FAIL ", "assertion:sym") - .return (rx1348_cur) + rx1349_done: + rx1349_cur."!cursor_fail"() + rx1349_cur."!cursor_debug"("FAIL ", "assertion:sym<{ }>") + .return (rx1349_cur) .return () .end .namespace ["NQP";"Regex"] -.sub "!PREFIX__assertion:sym" :subid("350_1275511697.61926") :method -.annotate 'line', 550 - new $P1350, "ResizablePMCArray" - push $P1350, "$" - push $P1350, "@" - .return ($P1350) +.sub "!PREFIX__assertion:sym<{ }>" :subid("351_1275600007.84296") :method +.annotate 'line', 562 + new $P1351, "ResizablePMCArray" + push $P1351, "{" + .return ($P1351) .end .namespace ["NQP";"Regex"] -.sub "codeblock" :subid("351_1275511697.61926") :method :outer("332_1275511697.61926") -.annotate 'line', 550 - .local string rx1353_tgt - .local int rx1353_pos - .local int rx1353_off - .local int rx1353_eos - .local int rx1353_rep - .local pmc rx1353_cur - (rx1353_cur, rx1353_pos, rx1353_tgt) = self."!cursor_start"() - rx1353_cur."!cursor_debug"("START ", "codeblock") - .lex unicode:"$\x{a2}", rx1353_cur +.sub "assertion:sym" :subid("352_1275600007.84296") :method :outer("341_1275600007.84296") +.annotate 'line', 562 + .const 'Sub' $P1359 = "354_1275600007.84296" + capture_lex $P1359 + .local string rx1354_tgt + .local int rx1354_pos + .local int rx1354_off + .local int rx1354_eos + .local int rx1354_rep + .local pmc rx1354_cur + (rx1354_cur, rx1354_pos, rx1354_tgt) = self."!cursor_start"() + rx1354_cur."!cursor_debug"("START ", "assertion:sym") + .lex unicode:"$\x{a2}", rx1354_cur .local pmc match .lex "$/", match - length rx1353_eos, rx1353_tgt - gt rx1353_pos, rx1353_eos, rx1353_done - set rx1353_off, 0 - lt rx1353_pos, 2, rx1353_start - sub rx1353_off, rx1353_pos, 1 - substr rx1353_tgt, rx1353_tgt, rx1353_off - rx1353_start: + length rx1354_eos, rx1354_tgt + gt rx1354_pos, rx1354_eos, rx1354_done + set rx1354_off, 0 + lt rx1354_pos, 2, rx1354_start + sub rx1354_off, rx1354_pos, 1 + substr rx1354_tgt, rx1354_tgt, rx1354_off + rx1354_start: $I10 = self.'from'() ne $I10, -1, rxscan1357_done goto rxscan1357_scan rxscan1357_loop: - ($P10) = rx1353_cur."from"() + ($P10) = rx1354_cur."from"() inc $P10 - set rx1353_pos, $P10 - ge rx1353_pos, rx1353_eos, rxscan1357_done + set rx1354_pos, $P10 + ge rx1354_pos, rx1354_eos, rxscan1357_done rxscan1357_scan: set_addr $I10, rxscan1357_loop - rx1353_cur."!mark_push"(0, rx1353_pos, $I10) + rx1354_cur."!mark_push"(0, rx1354_pos, $I10) rxscan1357_done: +.annotate 'line', 580 + # rx subcapture "zw" + set_addr $I10, rxcap_1362_fail + rx1354_cur."!mark_push"(0, rx1354_pos, $I10) + # rx enumcharlist negate=0 + ge rx1354_pos, rx1354_eos, rx1354_fail + sub $I10, rx1354_pos, rx1354_off + substr $S10, rx1354_tgt, $I10, 1 + index $I11, "?!", $S10 + lt $I11, 0, rx1354_fail + inc rx1354_pos + # rx subrule "before" subtype=zerowidth negate= + rx1354_cur."!cursor_pos"(rx1354_pos) + .const 'Sub' $P1359 = "354_1275600007.84296" + capture_lex $P1359 + $P10 = rx1354_cur."before"($P1359) + unless $P10, rx1354_fail + set_addr $I10, rxcap_1362_fail + ($I12, $I11) = rx1354_cur."!mark_peek"($I10) + rx1354_cur."!cursor_pos"($I11) + ($P10) = rx1354_cur."!cursor_start"() + $P10."!cursor_pass"(rx1354_pos, "") + rx1354_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("zw") + goto rxcap_1362_done + rxcap_1362_fail: + goto rx1354_fail + rxcap_1362_done: + # rx subrule "codeblock" subtype=capture negate= + rx1354_cur."!cursor_pos"(rx1354_pos) + $P10 = rx1354_cur."codeblock"() + unless $P10, rx1354_fail + rx1354_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("codeblock") + rx1354_pos = $P10."pos"() +.annotate 'line', 579 + # rx pass + rx1354_cur."!cursor_pass"(rx1354_pos, "assertion:sym") + rx1354_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx1354_pos) + .return (rx1354_cur) + rx1354_fail: +.annotate 'line', 562 + (rx1354_rep, rx1354_pos, $I10, $P10) = rx1354_cur."!mark_fail"(0) + lt rx1354_pos, -1, rx1354_done + eq rx1354_pos, -1, rx1354_fail + jump $I10 + rx1354_done: + rx1354_cur."!cursor_fail"() + rx1354_cur."!cursor_debug"("FAIL ", "assertion:sym") + .return (rx1354_cur) + .return () +.end + + +.namespace ["NQP";"Regex"] +.sub "!PREFIX__assertion:sym" :subid("353_1275600007.84296") :method +.annotate 'line', 562 + new $P1356, "ResizablePMCArray" + push $P1356, "!" + push $P1356, "?" + .return ($P1356) +.end + + +.namespace ["NQP";"Regex"] +.sub "_block1358" :anon :subid("354_1275600007.84296") :method :outer("352_1275600007.84296") +.annotate 'line', 580 + .local string rx1360_tgt + .local int rx1360_pos + .local int rx1360_off + .local int rx1360_eos + .local int rx1360_rep + .local pmc rx1360_cur + (rx1360_cur, rx1360_pos, rx1360_tgt) = self."!cursor_start"() + rx1360_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx1360_cur + .local pmc match + .lex "$/", match + length rx1360_eos, rx1360_tgt + gt rx1360_pos, rx1360_eos, rx1360_done + set rx1360_off, 0 + lt rx1360_pos, 2, rx1360_start + sub rx1360_off, rx1360_pos, 1 + substr rx1360_tgt, rx1360_tgt, rx1360_off + rx1360_start: + $I10 = self.'from'() + ne $I10, -1, rxscan1361_done + goto rxscan1361_scan + rxscan1361_loop: + ($P10) = rx1360_cur."from"() + inc $P10 + set rx1360_pos, $P10 + ge rx1360_pos, rx1360_eos, rxscan1361_done + rxscan1361_scan: + set_addr $I10, rxscan1361_loop + rx1360_cur."!mark_push"(0, rx1360_pos, $I10) + rxscan1361_done: + # rx literal "{" + add $I11, rx1360_pos, 1 + gt $I11, rx1360_eos, rx1360_fail + sub $I11, rx1360_pos, rx1360_off + substr $S10, rx1360_tgt, $I11, 1 + ne $S10, "{", rx1360_fail + add rx1360_pos, 1 + # rx pass + rx1360_cur."!cursor_pass"(rx1360_pos, "") + rx1360_cur."!cursor_debug"("PASS ", "", " at pos=", rx1360_pos) + .return (rx1360_cur) + rx1360_fail: + (rx1360_rep, rx1360_pos, $I10, $P10) = rx1360_cur."!mark_fail"(0) + lt rx1360_pos, -1, rx1360_done + eq rx1360_pos, -1, rx1360_fail + jump $I10 + rx1360_done: + rx1360_cur."!cursor_fail"() + rx1360_cur."!cursor_debug"("FAIL ", "") + .return (rx1360_cur) + .return () +.end + + +.namespace ["NQP";"Regex"] +.sub "assertion:sym" :subid("355_1275600007.84296") :method :outer("341_1275600007.84296") +.annotate 'line', 562 + .const 'Sub' $P1372 = "357_1275600007.84296" + capture_lex $P1372 + .local string rx1364_tgt + .local int rx1364_pos + .local int rx1364_off + .local int rx1364_eos + .local int rx1364_rep + .local pmc rx1364_cur + (rx1364_cur, rx1364_pos, rx1364_tgt) = self."!cursor_start"() + rx1364_cur."!cursor_debug"("START ", "assertion:sym") + rx1364_cur."!cursor_caparray"("nibbler", "arglist", "assertion") + .lex unicode:"$\x{a2}", rx1364_cur + .local pmc match + .lex "$/", match + length rx1364_eos, rx1364_tgt + gt rx1364_pos, rx1364_eos, rx1364_done + set rx1364_off, 0 + lt rx1364_pos, 2, rx1364_start + sub rx1364_off, rx1364_pos, 1 + substr rx1364_tgt, rx1364_tgt, rx1364_off + rx1364_start: + $I10 = self.'from'() + ne $I10, -1, rxscan1367_done + goto rxscan1367_scan + rxscan1367_loop: + ($P10) = rx1364_cur."from"() + inc $P10 + set rx1364_pos, $P10 + ge rx1364_pos, rx1364_eos, rxscan1367_done + rxscan1367_scan: + set_addr $I10, rxscan1367_loop + rx1364_cur."!mark_push"(0, rx1364_pos, $I10) + rxscan1367_done: +.annotate 'line', 584 + # rx subcapture "longname" + set_addr $I10, rxcap_1368_fail + rx1364_cur."!mark_push"(0, rx1364_pos, $I10) + # rx charclass_q w r 1..-1 + sub $I10, rx1364_pos, rx1364_off + find_not_cclass $I11, 8192, rx1364_tgt, $I10, rx1364_eos + add $I12, $I10, 1 + lt $I11, $I12, rx1364_fail + add rx1364_pos, rx1364_off, $I11 + set_addr $I10, rxcap_1368_fail + ($I12, $I11) = rx1364_cur."!mark_peek"($I10) + rx1364_cur."!cursor_pos"($I11) + ($P10) = rx1364_cur."!cursor_start"() + $P10."!cursor_pass"(rx1364_pos, "") + rx1364_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("longname") + goto rxcap_1368_done + rxcap_1368_fail: + goto rx1364_fail + rxcap_1368_done: +.annotate 'line', 591 + # rx rxquantr1369 ** 0..1 + set_addr $I1375, rxquantr1369_done + rx1364_cur."!mark_push"(0, rx1364_pos, $I1375) + rxquantr1369_loop: + alt1370_0: +.annotate 'line', 585 + set_addr $I10, alt1370_1 + rx1364_cur."!mark_push"(0, rx1364_pos, $I10) +.annotate 'line', 586 + # rx subrule "before" subtype=zerowidth negate= + rx1364_cur."!cursor_pos"(rx1364_pos) + .const 'Sub' $P1372 = "357_1275600007.84296" + capture_lex $P1372 + $P10 = rx1364_cur."before"($P1372) + unless $P10, rx1364_fail + goto alt1370_end + alt1370_1: + set_addr $I10, alt1370_2 + rx1364_cur."!mark_push"(0, rx1364_pos, $I10) .annotate 'line', 587 + # rx literal "=" + add $I11, rx1364_pos, 1 + gt $I11, rx1364_eos, rx1364_fail + sub $I11, rx1364_pos, rx1364_off + substr $S10, rx1364_tgt, $I11, 1 + ne $S10, "=", rx1364_fail + add rx1364_pos, 1 + # rx subrule "assertion" subtype=capture negate= + rx1364_cur."!cursor_pos"(rx1364_pos) + $P10 = rx1364_cur."assertion"() + unless $P10, rx1364_fail + rx1364_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("assertion") + rx1364_pos = $P10."pos"() + goto alt1370_end + alt1370_2: + set_addr $I10, alt1370_3 + rx1364_cur."!mark_push"(0, rx1364_pos, $I10) +.annotate 'line', 588 + # rx literal ":" + add $I11, rx1364_pos, 1 + gt $I11, rx1364_eos, rx1364_fail + sub $I11, rx1364_pos, rx1364_off + substr $S10, rx1364_tgt, $I11, 1 + ne $S10, ":", rx1364_fail + add rx1364_pos, 1 + # rx subrule "arglist" subtype=capture negate= + rx1364_cur."!cursor_pos"(rx1364_pos) + $P10 = rx1364_cur."arglist"() + unless $P10, rx1364_fail + rx1364_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("arglist") + rx1364_pos = $P10."pos"() + goto alt1370_end + alt1370_3: + set_addr $I10, alt1370_4 + rx1364_cur."!mark_push"(0, rx1364_pos, $I10) +.annotate 'line', 589 + # rx literal "(" + add $I11, rx1364_pos, 1 + gt $I11, rx1364_eos, rx1364_fail + sub $I11, rx1364_pos, rx1364_off + substr $S10, rx1364_tgt, $I11, 1 + ne $S10, "(", rx1364_fail + add rx1364_pos, 1 # rx subrule "LANG" subtype=capture negate= - rx1353_cur."!cursor_pos"(rx1353_pos) - $P10 = rx1353_cur."LANG"("MAIN", "pblock") - unless $P10, rx1353_fail - rx1353_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("block") - rx1353_pos = $P10."pos"() + rx1364_cur."!cursor_pos"(rx1364_pos) + $P10 = rx1364_cur."LANG"("MAIN", "arglist") + unless $P10, rx1364_fail + rx1364_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("arglist") + rx1364_pos = $P10."pos"() + # rx literal ")" + add $I11, rx1364_pos, 1 + gt $I11, rx1364_eos, rx1364_fail + sub $I11, rx1364_pos, rx1364_off + substr $S10, rx1364_tgt, $I11, 1 + ne $S10, ")", rx1364_fail + add rx1364_pos, 1 + goto alt1370_end + alt1370_4: +.annotate 'line', 590 + # rx subrule "normspace" subtype=method negate= + rx1364_cur."!cursor_pos"(rx1364_pos) + $P10 = rx1364_cur."normspace"() + unless $P10, rx1364_fail + rx1364_pos = $P10."pos"() + # rx subrule "nibbler" subtype=capture negate= + rx1364_cur."!cursor_pos"(rx1364_pos) + $P10 = rx1364_cur."nibbler"() + unless $P10, rx1364_fail + rx1364_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("nibbler") + rx1364_pos = $P10."pos"() + alt1370_end: +.annotate 'line', 591 + (rx1364_rep) = rx1364_cur."!mark_commit"($I1375) + rxquantr1369_done: +.annotate 'line', 583 + # rx pass + rx1364_cur."!cursor_pass"(rx1364_pos, "assertion:sym") + rx1364_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx1364_pos) + .return (rx1364_cur) + rx1364_fail: +.annotate 'line', 562 + (rx1364_rep, rx1364_pos, $I10, $P10) = rx1364_cur."!mark_fail"(0) + lt rx1364_pos, -1, rx1364_done + eq rx1364_pos, -1, rx1364_fail + jump $I10 + rx1364_done: + rx1364_cur."!cursor_fail"() + rx1364_cur."!cursor_debug"("FAIL ", "assertion:sym") + .return (rx1364_cur) + .return () +.end + + +.namespace ["NQP";"Regex"] +.sub "!PREFIX__assertion:sym" :subid("356_1275600007.84296") :method +.annotate 'line', 562 + new $P1366, "ResizablePMCArray" + push $P1366, "" + .return ($P1366) +.end + + +.namespace ["NQP";"Regex"] +.sub "_block1371" :anon :subid("357_1275600007.84296") :method :outer("355_1275600007.84296") .annotate 'line', 586 + .local string rx1373_tgt + .local int rx1373_pos + .local int rx1373_off + .local int rx1373_eos + .local int rx1373_rep + .local pmc rx1373_cur + (rx1373_cur, rx1373_pos, rx1373_tgt) = self."!cursor_start"() + rx1373_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx1373_cur + .local pmc match + .lex "$/", match + length rx1373_eos, rx1373_tgt + gt rx1373_pos, rx1373_eos, rx1373_done + set rx1373_off, 0 + lt rx1373_pos, 2, rx1373_start + sub rx1373_off, rx1373_pos, 1 + substr rx1373_tgt, rx1373_tgt, rx1373_off + rx1373_start: + $I10 = self.'from'() + ne $I10, -1, rxscan1374_done + goto rxscan1374_scan + rxscan1374_loop: + ($P10) = rx1373_cur."from"() + inc $P10 + set rx1373_pos, $P10 + ge rx1373_pos, rx1373_eos, rxscan1374_done + rxscan1374_scan: + set_addr $I10, rxscan1374_loop + rx1373_cur."!mark_push"(0, rx1373_pos, $I10) + rxscan1374_done: + # rx literal ">" + add $I11, rx1373_pos, 1 + gt $I11, rx1373_eos, rx1373_fail + sub $I11, rx1373_pos, rx1373_off + substr $S10, rx1373_tgt, $I11, 1 + ne $S10, ">", rx1373_fail + add rx1373_pos, 1 # rx pass - rx1353_cur."!cursor_pass"(rx1353_pos, "codeblock") - rx1353_cur."!cursor_debug"("PASS ", "codeblock", " at pos=", rx1353_pos) - .return (rx1353_cur) - rx1353_fail: -.annotate 'line', 550 - (rx1353_rep, rx1353_pos, $I10, $P10) = rx1353_cur."!mark_fail"(0) - lt rx1353_pos, -1, rx1353_done - eq rx1353_pos, -1, rx1353_fail + rx1373_cur."!cursor_pass"(rx1373_pos, "") + rx1373_cur."!cursor_debug"("PASS ", "", " at pos=", rx1373_pos) + .return (rx1373_cur) + rx1373_fail: + (rx1373_rep, rx1373_pos, $I10, $P10) = rx1373_cur."!mark_fail"(0) + lt rx1373_pos, -1, rx1373_done + eq rx1373_pos, -1, rx1373_fail jump $I10 - rx1353_done: - rx1353_cur."!cursor_fail"() - rx1353_cur."!cursor_debug"("FAIL ", "codeblock") - .return (rx1353_cur) + rx1373_done: + rx1373_cur."!cursor_fail"() + rx1373_cur."!cursor_debug"("FAIL ", "") + .return (rx1373_cur) .return () .end .namespace ["NQP";"Regex"] -.sub "!PREFIX__codeblock" :subid("352_1275511697.61926") :method -.annotate 'line', 550 - $P1355 = self."!PREFIX__!subrule"("block", "") - new $P1356, "ResizablePMCArray" - push $P1356, $P1355 - .return ($P1356) +.sub "assertion:sym" :subid("358_1275600007.84296") :method :outer("341_1275600007.84296") +.annotate 'line', 562 + .local string rx1377_tgt + .local int rx1377_pos + .local int rx1377_off + .local int rx1377_eos + .local int rx1377_rep + .local pmc rx1377_cur + (rx1377_cur, rx1377_pos, rx1377_tgt) = self."!cursor_start"() + rx1377_cur."!cursor_debug"("START ", "assertion:sym") + .lex unicode:"$\x{a2}", rx1377_cur + .local pmc match + .lex "$/", match + length rx1377_eos, rx1377_tgt + gt rx1377_pos, rx1377_eos, rx1377_done + set rx1377_off, 0 + lt rx1377_pos, 2, rx1377_start + sub rx1377_off, rx1377_pos, 1 + substr rx1377_tgt, rx1377_tgt, rx1377_off + rx1377_start: + $I10 = self.'from'() + ne $I10, -1, rxscan1380_done + goto rxscan1380_scan + rxscan1380_loop: + ($P10) = rx1377_cur."from"() + inc $P10 + set rx1377_pos, $P10 + ge rx1377_pos, rx1377_eos, rxscan1380_done + rxscan1380_scan: + set_addr $I10, rxscan1380_loop + rx1377_cur."!mark_push"(0, rx1377_pos, $I10) + rxscan1380_done: +.annotate 'line', 595 + # rx enumcharlist negate=0 zerowidth + ge rx1377_pos, rx1377_eos, rx1377_fail + sub $I10, rx1377_pos, rx1377_off + substr $S10, rx1377_tgt, $I10, 1 + index $I11, "$@", $S10 + lt $I11, 0, rx1377_fail + # rx subrule "LANG" subtype=capture negate= + rx1377_cur."!cursor_pos"(rx1377_pos) + $P10 = rx1377_cur."LANG"("MAIN", "variable") + unless $P10, rx1377_fail + rx1377_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("var") + rx1377_pos = $P10."pos"() +.annotate 'line', 594 + # rx pass + rx1377_cur."!cursor_pass"(rx1377_pos, "assertion:sym") + rx1377_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx1377_pos) + .return (rx1377_cur) + rx1377_fail: +.annotate 'line', 562 + (rx1377_rep, rx1377_pos, $I10, $P10) = rx1377_cur."!mark_fail"(0) + lt rx1377_pos, -1, rx1377_done + eq rx1377_pos, -1, rx1377_fail + jump $I10 + rx1377_done: + rx1377_cur."!cursor_fail"() + rx1377_cur."!cursor_debug"("FAIL ", "assertion:sym") + .return (rx1377_cur) + .return () +.end + + +.namespace ["NQP";"Regex"] +.sub "!PREFIX__assertion:sym" :subid("359_1275600007.84296") :method +.annotate 'line', 562 + new $P1379, "ResizablePMCArray" + push $P1379, "$" + push $P1379, "@" + .return ($P1379) +.end + + +.namespace ["NQP";"Regex"] +.sub "codeblock" :subid("360_1275600007.84296") :method :outer("341_1275600007.84296") +.annotate 'line', 562 + .local string rx1382_tgt + .local int rx1382_pos + .local int rx1382_off + .local int rx1382_eos + .local int rx1382_rep + .local pmc rx1382_cur + (rx1382_cur, rx1382_pos, rx1382_tgt) = self."!cursor_start"() + rx1382_cur."!cursor_debug"("START ", "codeblock") + .lex unicode:"$\x{a2}", rx1382_cur + .local pmc match + .lex "$/", match + length rx1382_eos, rx1382_tgt + gt rx1382_pos, rx1382_eos, rx1382_done + set rx1382_off, 0 + lt rx1382_pos, 2, rx1382_start + sub rx1382_off, rx1382_pos, 1 + substr rx1382_tgt, rx1382_tgt, rx1382_off + rx1382_start: + $I10 = self.'from'() + ne $I10, -1, rxscan1386_done + goto rxscan1386_scan + rxscan1386_loop: + ($P10) = rx1382_cur."from"() + inc $P10 + set rx1382_pos, $P10 + ge rx1382_pos, rx1382_eos, rxscan1386_done + rxscan1386_scan: + set_addr $I10, rxscan1386_loop + rx1382_cur."!mark_push"(0, rx1382_pos, $I10) + rxscan1386_done: +.annotate 'line', 599 + # rx subrule "LANG" subtype=capture negate= + rx1382_cur."!cursor_pos"(rx1382_pos) + $P10 = rx1382_cur."LANG"("MAIN", "pblock") + unless $P10, rx1382_fail + rx1382_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("block") + rx1382_pos = $P10."pos"() +.annotate 'line', 598 + # rx pass + rx1382_cur."!cursor_pass"(rx1382_pos, "codeblock") + rx1382_cur."!cursor_debug"("PASS ", "codeblock", " at pos=", rx1382_pos) + .return (rx1382_cur) + rx1382_fail: +.annotate 'line', 562 + (rx1382_rep, rx1382_pos, $I10, $P10) = rx1382_cur."!mark_fail"(0) + lt rx1382_pos, -1, rx1382_done + eq rx1382_pos, -1, rx1382_fail + jump $I10 + rx1382_done: + rx1382_cur."!cursor_fail"() + rx1382_cur."!cursor_debug"("FAIL ", "codeblock") + .return (rx1382_cur) + .return () +.end + + +.namespace ["NQP";"Regex"] +.sub "!PREFIX__codeblock" :subid("361_1275600007.84296") :method +.annotate 'line', 562 + $P1384 = self."!PREFIX__!subrule"("block", "") + new $P1385, "ResizablePMCArray" + push $P1385, $P1384 + .return ($P1385) .end .namespace ["NQP";"Grammar"] -.sub "_block1359" :load :anon :subid("353_1275511697.61926") +.sub "_block1388" :load :anon :subid("362_1275600007.84296") .annotate 'line', 4 - .const 'Sub' $P1361 = "11_1275511697.61926" - $P1362 = $P1361() - .return ($P1362) + .const 'Sub' $P1390 = "11_1275600007.84296" + $P1391 = $P1390() + .return ($P1391) .end .namespace [] -.sub "_block1380" :load :anon :subid("354_1275511697.61926") +.sub "_block1409" :load :anon :subid("363_1275600007.84296") .annotate 'line', 1 - .const 'Sub' $P1382 = "10_1275511697.61926" - $P1383 = $P1382() - .return ($P1383) + .const 'Sub' $P1411 = "10_1275600007.84296" + $P1412 = $P1411() + .return ($P1412) .end ### .include 'gen/nqp-actions.pir' .namespace [] -.sub "_block11" :anon :subid("10_1275511729.89077") +.sub "_block11" :anon :subid("10_1275600017.58296") .annotate 'line', 0 get_hll_global $P14, ["NQP";"Actions"], "_block13" capture_lex $P14 @@ -17061,261 +17429,265 @@ NQP::Compiler - NQP compiler .annotate 'line', 3 get_hll_global $P14, ["NQP";"Actions"], "_block13" capture_lex $P14 - $P2323 = $P14() + $P2424 = $P14() .annotate 'line', 1 - .return ($P2323) - .const 'Sub' $P2325 = "137_1275511729.89077" - .return ($P2325) + .return ($P2424) + .const 'Sub' $P2426 = "143_1275600017.58296" + .return ($P2426) .end .namespace [] -.sub "" :load :init :subid("post138") :outer("10_1275511729.89077") +.sub "" :load :init :subid("post144") :outer("10_1275600017.58296") .annotate 'line', 0 - .const 'Sub' $P12 = "10_1275511729.89077" + .const 'Sub' $P12 = "10_1275600017.58296" .local pmc block set block, $P12 - $P2328 = get_root_global ["parrot"], "P6metaclass" - $P2328."new_class"("NQP::Actions", "HLL::Actions" :named("parent")) + $P2429 = get_root_global ["parrot"], "P6metaclass" + $P2429."new_class"("NQP::Actions", "HLL::Actions" :named("parent")) .end .namespace ["NQP";"Actions"] -.sub "_block13" :subid("11_1275511729.89077") :outer("10_1275511729.89077") +.sub "_block13" :subid("11_1275600017.58296") :outer("10_1275600017.58296") .annotate 'line', 3 - .const 'Sub' $P2319 = "136_1275511729.89077" - capture_lex $P2319 - get_hll_global $P2203, ["NQP";"RegexActions"], "_block2202" - capture_lex $P2203 - .const 'Sub' $P2192 = "126_1275511729.89077" - capture_lex $P2192 - .const 'Sub' $P2185 = "125_1275511729.89077" - capture_lex $P2185 - .const 'Sub' $P2178 = "124_1275511729.89077" - capture_lex $P2178 - .const 'Sub' $P2171 = "123_1275511729.89077" - capture_lex $P2171 - .const 'Sub' $P2158 = "122_1275511729.89077" - capture_lex $P2158 - .const 'Sub' $P2148 = "121_1275511729.89077" - capture_lex $P2148 - .const 'Sub' $P2138 = "120_1275511729.89077" - capture_lex $P2138 - .const 'Sub' $P2128 = "119_1275511729.89077" - capture_lex $P2128 - .const 'Sub' $P2121 = "118_1275511729.89077" - capture_lex $P2121 - .const 'Sub' $P2107 = "117_1275511729.89077" + .const 'Sub' $P2420 = "142_1275600017.58296" + capture_lex $P2420 + get_hll_global $P2304, ["NQP";"RegexActions"], "_block2303" + capture_lex $P2304 + .const 'Sub' $P2293 = "132_1275600017.58296" + capture_lex $P2293 + .const 'Sub' $P2286 = "131_1275600017.58296" + capture_lex $P2286 + .const 'Sub' $P2279 = "130_1275600017.58296" + capture_lex $P2279 + .const 'Sub' $P2272 = "129_1275600017.58296" + capture_lex $P2272 + .const 'Sub' $P2259 = "128_1275600017.58296" + capture_lex $P2259 + .const 'Sub' $P2249 = "127_1275600017.58296" + capture_lex $P2249 + .const 'Sub' $P2239 = "126_1275600017.58296" + capture_lex $P2239 + .const 'Sub' $P2229 = "125_1275600017.58296" + capture_lex $P2229 + .const 'Sub' $P2222 = "124_1275600017.58296" + capture_lex $P2222 + .const 'Sub' $P2208 = "123_1275600017.58296" + capture_lex $P2208 + .const 'Sub' $P2198 = "122_1275600017.58296" + capture_lex $P2198 + .const 'Sub' $P2161 = "121_1275600017.58296" + capture_lex $P2161 + .const 'Sub' $P2147 = "120_1275600017.58296" + capture_lex $P2147 + .const 'Sub' $P2137 = "119_1275600017.58296" + capture_lex $P2137 + .const 'Sub' $P2127 = "118_1275600017.58296" + capture_lex $P2127 + .const 'Sub' $P2117 = "117_1275600017.58296" + capture_lex $P2117 + .const 'Sub' $P2107 = "116_1275600017.58296" capture_lex $P2107 - .const 'Sub' $P2097 = "116_1275511729.89077" + .const 'Sub' $P2097 = "115_1275600017.58296" capture_lex $P2097 - .const 'Sub' $P2060 = "115_1275511729.89077" - capture_lex $P2060 - .const 'Sub' $P2046 = "114_1275511729.89077" - capture_lex $P2046 - .const 'Sub' $P2036 = "113_1275511729.89077" - capture_lex $P2036 - .const 'Sub' $P2026 = "112_1275511729.89077" - capture_lex $P2026 - .const 'Sub' $P2016 = "111_1275511729.89077" + .const 'Sub' $P2069 = "114_1275600017.58296" + capture_lex $P2069 + .const 'Sub' $P2052 = "113_1275600017.58296" + capture_lex $P2052 + .const 'Sub' $P2042 = "112_1275600017.58296" + capture_lex $P2042 + .const 'Sub' $P2029 = "111_1275600017.58296" + capture_lex $P2029 + .const 'Sub' $P2016 = "110_1275600017.58296" capture_lex $P2016 - .const 'Sub' $P2006 = "110_1275511729.89077" - capture_lex $P2006 - .const 'Sub' $P1996 = "109_1275511729.89077" - capture_lex $P1996 - .const 'Sub' $P1968 = "108_1275511729.89077" - capture_lex $P1968 - .const 'Sub' $P1951 = "107_1275511729.89077" - capture_lex $P1951 - .const 'Sub' $P1941 = "106_1275511729.89077" - capture_lex $P1941 - .const 'Sub' $P1928 = "105_1275511729.89077" - capture_lex $P1928 - .const 'Sub' $P1915 = "104_1275511729.89077" - capture_lex $P1915 - .const 'Sub' $P1902 = "103_1275511729.89077" - capture_lex $P1902 - .const 'Sub' $P1892 = "102_1275511729.89077" - capture_lex $P1892 - .const 'Sub' $P1863 = "101_1275511729.89077" - capture_lex $P1863 - .const 'Sub' $P1839 = "100_1275511729.89077" - capture_lex $P1839 - .const 'Sub' $P1829 = "99_1275511729.89077" - capture_lex $P1829 - .const 'Sub' $P1819 = "98_1275511729.89077" - capture_lex $P1819 - .const 'Sub' $P1792 = "97_1275511729.89077" - capture_lex $P1792 - .const 'Sub' $P1774 = "96_1275511729.89077" - capture_lex $P1774 - .const 'Sub' $P1764 = "95_1275511729.89077" - capture_lex $P1764 - .const 'Sub' $P1660 = "92_1275511729.89077" - capture_lex $P1660 - .const 'Sub' $P1650 = "91_1275511729.89077" - capture_lex $P1650 - .const 'Sub' $P1621 = "90_1275511729.89077" - capture_lex $P1621 - .const 'Sub' $P1579 = "89_1275511729.89077" - capture_lex $P1579 - .const 'Sub' $P1563 = "88_1275511729.89077" - capture_lex $P1563 - .const 'Sub' $P1554 = "87_1275511729.89077" - capture_lex $P1554 - .const 'Sub' $P1522 = "86_1275511729.89077" - capture_lex $P1522 - .const 'Sub' $P1423 = "83_1275511729.89077" - capture_lex $P1423 - .const 'Sub' $P1406 = "82_1275511729.89077" - capture_lex $P1406 - .const 'Sub' $P1386 = "81_1275511729.89077" - capture_lex $P1386 - .const 'Sub' $P1302 = "80_1275511729.89077" - capture_lex $P1302 - .const 'Sub' $P1278 = "78_1275511729.89077" + .const 'Sub' $P2003 = "109_1275600017.58296" + capture_lex $P2003 + .const 'Sub' $P1993 = "108_1275600017.58296" + capture_lex $P1993 + .const 'Sub' $P1964 = "107_1275600017.58296" + capture_lex $P1964 + .const 'Sub' $P1940 = "106_1275600017.58296" + capture_lex $P1940 + .const 'Sub' $P1930 = "105_1275600017.58296" + capture_lex $P1930 + .const 'Sub' $P1920 = "104_1275600017.58296" + capture_lex $P1920 + .const 'Sub' $P1893 = "103_1275600017.58296" + capture_lex $P1893 + .const 'Sub' $P1875 = "102_1275600017.58296" + capture_lex $P1875 + .const 'Sub' $P1865 = "101_1275600017.58296" + capture_lex $P1865 + .const 'Sub' $P1761 = "98_1275600017.58296" + capture_lex $P1761 + .const 'Sub' $P1751 = "97_1275600017.58296" + capture_lex $P1751 + .const 'Sub' $P1722 = "96_1275600017.58296" + capture_lex $P1722 + .const 'Sub' $P1680 = "95_1275600017.58296" + capture_lex $P1680 + .const 'Sub' $P1664 = "94_1275600017.58296" + capture_lex $P1664 + .const 'Sub' $P1655 = "93_1275600017.58296" + capture_lex $P1655 + .const 'Sub' $P1623 = "92_1275600017.58296" + capture_lex $P1623 + .const 'Sub' $P1524 = "89_1275600017.58296" + capture_lex $P1524 + .const 'Sub' $P1507 = "88_1275600017.58296" + capture_lex $P1507 + .const 'Sub' $P1487 = "87_1275600017.58296" + capture_lex $P1487 + .const 'Sub' $P1375 = "84_1275600017.58296" + capture_lex $P1375 + .const 'Sub' $P1318 = "80_1275600017.58296" + capture_lex $P1318 + .const 'Sub' $P1278 = "78_1275600017.58296" capture_lex $P1278 - .const 'Sub' $P1244 = "76_1275511729.89077" - capture_lex $P1244 - .const 'Sub' $P1194 = "74_1275511729.89077" - capture_lex $P1194 - .const 'Sub' $P1184 = "73_1275511729.89077" - capture_lex $P1184 - .const 'Sub' $P1174 = "72_1275511729.89077" - capture_lex $P1174 - .const 'Sub' $P1103 = "70_1275511729.89077" - capture_lex $P1103 - .const 'Sub' $P1086 = "69_1275511729.89077" - capture_lex $P1086 - .const 'Sub' $P1076 = "68_1275511729.89077" + .const 'Sub' $P1228 = "76_1275600017.58296" + capture_lex $P1228 + .const 'Sub' $P1218 = "75_1275600017.58296" + capture_lex $P1218 + .const 'Sub' $P1208 = "74_1275600017.58296" + capture_lex $P1208 + .const 'Sub' $P1137 = "72_1275600017.58296" + capture_lex $P1137 + .const 'Sub' $P1127 = "71_1275600017.58296" + capture_lex $P1127 + .const 'Sub' $P1110 = "70_1275600017.58296" + capture_lex $P1110 + .const 'Sub' $P1093 = "69_1275600017.58296" + capture_lex $P1093 + .const 'Sub' $P1076 = "68_1275600017.58296" capture_lex $P1076 - .const 'Sub' $P1066 = "67_1275511729.89077" + .const 'Sub' $P1066 = "67_1275600017.58296" capture_lex $P1066 - .const 'Sub' $P1056 = "66_1275511729.89077" + .const 'Sub' $P1056 = "66_1275600017.58296" capture_lex $P1056 - .const 'Sub' $P1046 = "65_1275511729.89077" + .const 'Sub' $P1046 = "65_1275600017.58296" capture_lex $P1046 - .const 'Sub' $P1022 = "64_1275511729.89077" + .const 'Sub' $P1022 = "64_1275600017.58296" capture_lex $P1022 - .const 'Sub' $P969 = "63_1275511729.89077" + .const 'Sub' $P969 = "63_1275600017.58296" capture_lex $P969 - .const 'Sub' $P959 = "62_1275511729.89077" + .const 'Sub' $P959 = "62_1275600017.58296" capture_lex $P959 - .const 'Sub' $P870 = "60_1275511729.89077" + .const 'Sub' $P870 = "60_1275600017.58296" capture_lex $P870 - .const 'Sub' $P844 = "59_1275511729.89077" + .const 'Sub' $P844 = "59_1275600017.58296" capture_lex $P844 - .const 'Sub' $P828 = "58_1275511729.89077" + .const 'Sub' $P828 = "58_1275600017.58296" capture_lex $P828 - .const 'Sub' $P818 = "57_1275511729.89077" + .const 'Sub' $P818 = "57_1275600017.58296" capture_lex $P818 - .const 'Sub' $P808 = "56_1275511729.89077" + .const 'Sub' $P808 = "56_1275600017.58296" capture_lex $P808 - .const 'Sub' $P798 = "55_1275511729.89077" + .const 'Sub' $P798 = "55_1275600017.58296" capture_lex $P798 - .const 'Sub' $P788 = "54_1275511729.89077" + .const 'Sub' $P788 = "54_1275600017.58296" capture_lex $P788 - .const 'Sub' $P778 = "53_1275511729.89077" + .const 'Sub' $P778 = "53_1275600017.58296" capture_lex $P778 - .const 'Sub' $P768 = "52_1275511729.89077" + .const 'Sub' $P768 = "52_1275600017.58296" capture_lex $P768 - .const 'Sub' $P758 = "51_1275511729.89077" + .const 'Sub' $P758 = "51_1275600017.58296" capture_lex $P758 - .const 'Sub' $P748 = "50_1275511729.89077" + .const 'Sub' $P748 = "50_1275600017.58296" capture_lex $P748 - .const 'Sub' $P738 = "49_1275511729.89077" + .const 'Sub' $P738 = "49_1275600017.58296" capture_lex $P738 - .const 'Sub' $P728 = "48_1275511729.89077" + .const 'Sub' $P728 = "48_1275600017.58296" capture_lex $P728 - .const 'Sub' $P718 = "47_1275511729.89077" + .const 'Sub' $P718 = "47_1275600017.58296" capture_lex $P718 - .const 'Sub' $P708 = "46_1275511729.89077" + .const 'Sub' $P708 = "46_1275600017.58296" capture_lex $P708 - .const 'Sub' $P698 = "45_1275511729.89077" + .const 'Sub' $P698 = "45_1275600017.58296" capture_lex $P698 - .const 'Sub' $P680 = "44_1275511729.89077" + .const 'Sub' $P680 = "44_1275600017.58296" capture_lex $P680 - .const 'Sub' $P645 = "43_1275511729.89077" + .const 'Sub' $P645 = "43_1275600017.58296" capture_lex $P645 - .const 'Sub' $P629 = "42_1275511729.89077" + .const 'Sub' $P629 = "42_1275600017.58296" capture_lex $P629 - .const 'Sub' $P608 = "41_1275511729.89077" + .const 'Sub' $P608 = "41_1275600017.58296" capture_lex $P608 - .const 'Sub' $P588 = "40_1275511729.89077" + .const 'Sub' $P588 = "40_1275600017.58296" capture_lex $P588 - .const 'Sub' $P575 = "39_1275511729.89077" + .const 'Sub' $P575 = "39_1275600017.58296" capture_lex $P575 - .const 'Sub' $P549 = "38_1275511729.89077" + .const 'Sub' $P549 = "38_1275600017.58296" capture_lex $P549 - .const 'Sub' $P513 = "37_1275511729.89077" + .const 'Sub' $P513 = "37_1275600017.58296" capture_lex $P513 - .const 'Sub' $P496 = "36_1275511729.89077" + .const 'Sub' $P496 = "36_1275600017.58296" capture_lex $P496 - .const 'Sub' $P482 = "35_1275511729.89077" + .const 'Sub' $P482 = "35_1275600017.58296" capture_lex $P482 - .const 'Sub' $P429 = "33_1275511729.89077" + .const 'Sub' $P429 = "33_1275600017.58296" capture_lex $P429 - .const 'Sub' $P418 = "32_1275511729.89077" + .const 'Sub' $P418 = "32_1275600017.58296" capture_lex $P418 - .const 'Sub' $P405 = "31_1275511729.89077" + .const 'Sub' $P405 = "31_1275600017.58296" capture_lex $P405 - .const 'Sub' $P385 = "30_1275511729.89077" + .const 'Sub' $P385 = "30_1275600017.58296" capture_lex $P385 - .const 'Sub' $P375 = "29_1275511729.89077" + .const 'Sub' $P375 = "29_1275600017.58296" capture_lex $P375 - .const 'Sub' $P365 = "28_1275511729.89077" + .const 'Sub' $P365 = "28_1275600017.58296" capture_lex $P365 - .const 'Sub' $P349 = "27_1275511729.89077" + .const 'Sub' $P349 = "27_1275600017.58296" capture_lex $P349 - .const 'Sub' $P289 = "25_1275511729.89077" + .const 'Sub' $P289 = "25_1275600017.58296" capture_lex $P289 - .const 'Sub' $P246 = "23_1275511729.89077" + .const 'Sub' $P246 = "23_1275600017.58296" capture_lex $P246 - .const 'Sub' $P214 = "22_1275511729.89077" + .const 'Sub' $P214 = "22_1275600017.58296" capture_lex $P214 - .const 'Sub' $P181 = "21_1275511729.89077" + .const 'Sub' $P181 = "21_1275600017.58296" capture_lex $P181 - .const 'Sub' $P171 = "20_1275511729.89077" + .const 'Sub' $P171 = "20_1275600017.58296" capture_lex $P171 - .const 'Sub' $P151 = "19_1275511729.89077" + .const 'Sub' $P151 = "19_1275600017.58296" capture_lex $P151 - .const 'Sub' $P100 = "18_1275511729.89077" + .const 'Sub' $P100 = "18_1275600017.58296" capture_lex $P100 - .const 'Sub' $P84 = "17_1275511729.89077" + .const 'Sub' $P84 = "17_1275600017.58296" capture_lex $P84 - .const 'Sub' $P63 = "16_1275511729.89077" + .const 'Sub' $P63 = "16_1275600017.58296" capture_lex $P63 - .const 'Sub' $P27 = "13_1275511729.89077" + .const 'Sub' $P27 = "13_1275600017.58296" capture_lex $P27 - .const 'Sub' $P16 = "12_1275511729.89077" + .const 'Sub' $P16 = "12_1275600017.58296" capture_lex $P16 get_global $P15, "@BLOCK" - unless_null $P15, vivify_141 + unless_null $P15, vivify_147 $P15 = root_new ['parrot';'ResizablePMCArray'] set_global "@BLOCK", $P15 - vivify_141: + vivify_147: .annotate 'line', 9 - .const 'Sub' $P16 = "12_1275511729.89077" + .const 'Sub' $P16 = "12_1275600017.58296" newclosure $P26, $P16 .lex "xblock_immediate", $P26 .annotate 'line', 14 - .const 'Sub' $P27 = "13_1275511729.89077" + .const 'Sub' $P27 = "13_1275600017.58296" newclosure $P62, $P27 .lex "block_immediate", $P62 .annotate 'line', 24 - .const 'Sub' $P63 = "16_1275511729.89077" + .const 'Sub' $P63 = "16_1275600017.58296" newclosure $P83, $P63 .lex "vivitype", $P83 .annotate 'line', 43 - .const 'Sub' $P84 = "17_1275511729.89077" + .const 'Sub' $P84 = "17_1275600017.58296" newclosure $P99, $P84 .lex "colonpair_str", $P99 .annotate 'line', 213 - .const 'Sub' $P100 = "18_1275511729.89077" + .const 'Sub' $P100 = "18_1275600017.58296" newclosure $P150, $P100 .lex "push_block_handler", $P150 -.annotate 'line', 797 - .const 'Sub' $P151 = "19_1275511729.89077" +.annotate 'line', 822 + .const 'Sub' $P151 = "19_1275600017.58296" newclosure $P166, $P151 .lex "control", $P166 .annotate 'line', 3 @@ -17334,51 +17706,51 @@ NQP::Compiler - NQP compiler find_lex $P213, "colonpair_str" .annotate 'line', 206 find_lex $P628, "push_block_handler" -.annotate 'line', 788 - find_lex $P2170, "control" -.annotate 'line', 819 - get_hll_global $P2203, ["NQP";"RegexActions"], "_block2202" - capture_lex $P2203 - $P2313 = $P2203() +.annotate 'line', 813 + find_lex $P2271, "control" +.annotate 'line', 844 + get_hll_global $P2304, ["NQP";"RegexActions"], "_block2303" + capture_lex $P2304 + $P2414 = $P2304() .annotate 'line', 3 - .return ($P2313) - .const 'Sub' $P2315 = "135_1275511729.89077" - .return ($P2315) + .return ($P2414) + .const 'Sub' $P2416 = "141_1275600017.58296" + .return ($P2416) .end .namespace ["NQP";"Actions"] -.sub "" :load :init :subid("post139") :outer("11_1275511729.89077") +.sub "" :load :init :subid("post145") :outer("11_1275600017.58296") .annotate 'line', 3 get_hll_global $P14, ["NQP";"Actions"], "_block13" .local pmc block set block, $P14 .annotate 'line', 5 - .const 'Sub' $P2319 = "136_1275511729.89077" - capture_lex $P2319 - $P2319() - $P2322 = get_root_global ["parrot"], "P6metaclass" - $P2322."new_class"("NQP::RegexActions", "Regex::P6Regex::Actions" :named("parent")) + .const 'Sub' $P2420 = "142_1275600017.58296" + capture_lex $P2420 + $P2420() + $P2423 = get_root_global ["parrot"], "P6metaclass" + $P2423."new_class"("NQP::RegexActions", "Regex::P6Regex::Actions" :named("parent")) .end .namespace ["NQP";"Actions"] -.sub "_block2318" :anon :subid("136_1275511729.89077") :outer("11_1275511729.89077") +.sub "_block2419" :anon :subid("142_1275600017.58296") :outer("11_1275600017.58296") .annotate 'line', 6 - get_global $P2320, "@BLOCK" - unless_null $P2320, vivify_140 - $P2320 = root_new ['parrot';'ResizablePMCArray'] - set_global "@BLOCK", $P2320 - vivify_140: - $P2321 = new ['ResizablePMCArray'] - set_global "@BLOCK", $P2321 + get_global $P2421, "@BLOCK" + unless_null $P2421, vivify_146 + $P2421 = root_new ['parrot';'ResizablePMCArray'] + set_global "@BLOCK", $P2421 + vivify_146: + $P2422 = new ['ResizablePMCArray'] + set_global "@BLOCK", $P2422 .annotate 'line', 5 - .return ($P2321) + .return ($P2422) .end .namespace ["NQP";"Actions"] -.sub "xblock_immediate" :subid("12_1275511729.89077") :outer("11_1275511729.89077") +.sub "xblock_immediate" :subid("12_1275600017.58296") :outer("11_1275600017.58296") .param pmc param_19 .annotate 'line', 9 new $P18, 'ExceptionHandler' @@ -17388,19 +17760,19 @@ NQP::Compiler - NQP compiler .lex "$xblock", param_19 .annotate 'line', 10 find_lex $P20, "$xblock" - unless_null $P20, vivify_142 + unless_null $P20, vivify_148 $P20 = root_new ['parrot';'ResizablePMCArray'] - vivify_142: + vivify_148: set $P21, $P20[1] - unless_null $P21, vivify_143 + unless_null $P21, vivify_149 new $P21, "Undef" - vivify_143: + vivify_149: $P22 = "block_immediate"($P21) find_lex $P23, "$xblock" - unless_null $P23, vivify_144 + unless_null $P23, vivify_150 $P23 = root_new ['parrot';'ResizablePMCArray'] store_lex "$xblock", $P23 - vivify_144: + vivify_150: set $P23[1], $P22 find_lex $P24, "$xblock" .annotate 'line', 9 @@ -17414,10 +17786,10 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "block_immediate" :subid("13_1275511729.89077") :outer("11_1275511729.89077") +.sub "block_immediate" :subid("13_1275600017.58296") :outer("11_1275600017.58296") .param pmc param_30 .annotate 'line', 14 - .const 'Sub' $P40 = "14_1275511729.89077" + .const 'Sub' $P40 = "14_1275600017.58296" capture_lex $P40 new $P29, 'ExceptionHandler' set_addr $P29, control_28 @@ -17439,7 +17811,7 @@ NQP::Compiler - NQP compiler set $P33, $P38 unless_34_end: if $P33, unless_32_end - .const 'Sub' $P40 = "14_1275511729.89077" + .const 'Sub' $P40 = "14_1275600017.58296" capture_lex $P40 $P40() unless_32_end: @@ -17455,9 +17827,9 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "_block39" :anon :subid("14_1275511729.89077") :outer("13_1275511729.89077") +.sub "_block39" :anon :subid("14_1275600017.58296") :outer("13_1275600017.58296") .annotate 'line', 16 - .const 'Sub' $P51 = "15_1275511729.89077" + .const 'Sub' $P51 = "15_1275600017.58296" capture_lex $P51 .annotate 'line', 17 new $P41, "Undef" @@ -17470,7 +17842,7 @@ NQP::Compiler - NQP compiler find_lex $P46, "$block" $P47 = $P46."list"() defined $I48, $P47 - unless $I48, for_undef_145 + unless $I48, for_undef_151 iter $P45, $P47 new $P57, 'ExceptionHandler' set_addr $P57, loop56_handler @@ -17480,7 +17852,7 @@ NQP::Compiler - NQP compiler unless $P45, loop56_done shift $P49, $P45 loop56_redo: - .const 'Sub' $P51 = "15_1275511729.89077" + .const 'Sub' $P51 = "15_1275600017.58296" capture_lex $P51 $P51($P49) loop56_next: @@ -17493,7 +17865,7 @@ NQP::Compiler - NQP compiler eq $P58, 66, loop56_redo loop56_done: pop_eh - for_undef_145: + for_undef_151: .annotate 'line', 19 find_lex $P59, "$stmts" store_lex "$block", $P59 @@ -17503,7 +17875,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "_block50" :anon :subid("15_1275511729.89077") :outer("14_1275511729.89077") +.sub "_block50" :anon :subid("15_1275600017.58296") :outer("14_1275600017.58296") .param pmc param_52 .annotate 'line', 18 .lex "$_", param_52 @@ -17515,7 +17887,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "vivitype" :subid("16_1275511729.89077") :outer("11_1275511729.89077") +.sub "vivitype" :subid("16_1275600017.58296") :outer("11_1275600017.58296") .param pmc param_66 .annotate 'line', 24 new $P65, 'ExceptionHandler' @@ -17563,7 +17935,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "colonpair_str" :subid("17_1275511729.89077") :outer("11_1275511729.89077") +.sub "colonpair_str" :subid("17_1275600017.58296") :outer("11_1275600017.58296") .param pmc param_87 .annotate 'line', 43 new $P86, 'ExceptionHandler' @@ -17601,7 +17973,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "push_block_handler" :subid("18_1275511729.89077") :outer("11_1275511729.89077") +.sub "push_block_handler" :subid("18_1275600017.58296") :outer("11_1275600017.58296") .param pmc param_103 .param pmc param_104 .annotate 'line', 213 @@ -17613,24 +17985,24 @@ NQP::Compiler - NQP compiler .lex "$block", param_104 .annotate 'line', 214 get_global $P106, "@BLOCK" - unless_null $P106, vivify_146 + unless_null $P106, vivify_152 $P106 = root_new ['parrot';'ResizablePMCArray'] - vivify_146: + vivify_152: set $P107, $P106[0] - unless_null $P107, vivify_147 + unless_null $P107, vivify_153 new $P107, "Undef" - vivify_147: + vivify_153: $P108 = $P107."handlers"() if $P108, unless_105_end .annotate 'line', 215 get_global $P109, "@BLOCK" - unless_null $P109, vivify_148 + unless_null $P109, vivify_154 $P109 = root_new ['parrot';'ResizablePMCArray'] - vivify_148: + vivify_154: set $P110, $P109[0] - unless_null $P110, vivify_149 + unless_null $P110, vivify_155 new $P110, "Undef" - vivify_149: + vivify_155: new $P111, "ResizablePMCArray" $P110."handlers"($P111) unless_105_end: @@ -17671,13 +18043,13 @@ NQP::Compiler - NQP compiler $P128."blocktype"("declaration") .annotate 'line', 230 get_global $P129, "@BLOCK" - unless_null $P129, vivify_150 + unless_null $P129, vivify_156 $P129 = root_new ['parrot';'ResizablePMCArray'] - vivify_150: + vivify_156: set $P130, $P129[0] - unless_null $P130, vivify_151 + unless_null $P130, vivify_157 new $P130, "Undef" - vivify_151: + vivify_157: $P131 = $P130."handlers"() .annotate 'line', 231 get_hll_global $P132, ["PAST"], "Control" @@ -17718,21 +18090,21 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "control" :subid("19_1275511729.89077") :outer("11_1275511729.89077") +.sub "control" :subid("19_1275600017.58296") :outer("11_1275600017.58296") .param pmc param_154 .param pmc param_155 -.annotate 'line', 797 +.annotate 'line', 822 new $P153, 'ExceptionHandler' set_addr $P153, control_152 $P153."handle_types"(57) push_eh $P153 .lex "$/", param_154 .lex "$id", param_155 -.annotate 'line', 798 +.annotate 'line', 823 find_lex $P156, "$/" get_hll_global $P157, ["PAST"], "Op" find_lex $P158, "$/" -.annotate 'line', 804 +.annotate 'line', 829 new $P159, "String" assign $P159, " %r[\"type\"] = " find_lex $P160, "$id" @@ -17743,9 +18115,9 @@ NQP::Compiler - NQP compiler push $P162, $P161 push $P162, " throw %r" $P163 = $P157."new"($P158 :named("node"), "inline" :named("pasttype"), $P162 :named("inline")) -.annotate 'line', 798 +.annotate 'line', 823 $P164 = $P156."!make"($P163) -.annotate 'line', 797 +.annotate 'line', 822 .return ($P164) control_152: .local pmc exception @@ -17756,7 +18128,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "TOP" :subid("20_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "TOP" :subid("20_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_174 .annotate 'line', 33 new $P173, 'ExceptionHandler' @@ -17767,13 +18139,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_174 find_lex $P175, "$/" find_lex $P176, "$/" - unless_null $P176, vivify_152 + unless_null $P176, vivify_158 $P176 = root_new ['parrot';'Hash'] - vivify_152: + vivify_158: set $P177, $P176["comp_unit"] - unless_null $P177, vivify_153 + unless_null $P177, vivify_159 new $P177, "Undef" - vivify_153: + vivify_159: $P178 = $P177."ast"() $P179 = $P175."!make"($P178) .return ($P179) @@ -17786,7 +18158,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "deflongname" :subid("21_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "deflongname" :subid("21_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_184 .annotate 'line', 35 new $P183, 'ExceptionHandler' @@ -17799,13 +18171,13 @@ NQP::Compiler - NQP compiler find_lex $P185, "$/" .annotate 'line', 37 find_lex $P188, "$/" - unless_null $P188, vivify_154 + unless_null $P188, vivify_160 $P188 = root_new ['parrot';'Hash'] - vivify_154: + vivify_160: set $P189, $P188["colonpair"] - unless_null $P189, vivify_155 + unless_null $P189, vivify_161 new $P189, "Undef" - vivify_155: + vivify_161: if $P189, if_187 .annotate 'line', 39 find_lex $P209, "$/" @@ -17816,46 +18188,46 @@ NQP::Compiler - NQP compiler goto if_187_end if_187: find_lex $P190, "$/" - unless_null $P190, vivify_156 + unless_null $P190, vivify_162 $P190 = root_new ['parrot';'Hash'] - vivify_156: + vivify_162: set $P191, $P190["identifier"] - unless_null $P191, vivify_157 + unless_null $P191, vivify_163 new $P191, "Undef" - vivify_157: + vivify_163: set $S192, $P191 new $P193, 'String' set $P193, $S192 concat $P194, $P193, ":" find_lex $P195, "$/" - unless_null $P195, vivify_158 + unless_null $P195, vivify_164 $P195 = root_new ['parrot';'Hash'] - vivify_158: + vivify_164: set $P196, $P195["colonpair"] - unless_null $P196, vivify_159 + unless_null $P196, vivify_165 $P196 = root_new ['parrot';'ResizablePMCArray'] - vivify_159: + vivify_165: set $P197, $P196[0] - unless_null $P197, vivify_160 + unless_null $P197, vivify_166 new $P197, "Undef" - vivify_160: + vivify_166: $P198 = $P197."ast"() $S199 = $P198."named"() concat $P200, $P194, $S199 concat $P201, $P200, "<" .annotate 'line', 38 find_lex $P202, "$/" - unless_null $P202, vivify_161 + unless_null $P202, vivify_167 $P202 = root_new ['parrot';'Hash'] - vivify_161: + vivify_167: set $P203, $P202["colonpair"] - unless_null $P203, vivify_162 + unless_null $P203, vivify_168 $P203 = root_new ['parrot';'ResizablePMCArray'] - vivify_162: + vivify_168: set $P204, $P203[0] - unless_null $P204, vivify_163 + unless_null $P204, vivify_169 new $P204, "Undef" - vivify_163: + vivify_169: $P205 = $P204."ast"() $S206 = "colonpair_str"($P205) concat $P207, $P201, $S206 @@ -17875,7 +18247,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "comp_unit" :subid("22_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "comp_unit" :subid("22_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_217 .annotate 'line', 49 new $P216, 'ExceptionHandler' @@ -17892,13 +18264,13 @@ NQP::Compiler - NQP compiler .lex "$unit", $P219 .annotate 'line', 50 find_lex $P220, "$/" - unless_null $P220, vivify_164 + unless_null $P220, vivify_170 $P220 = root_new ['parrot';'Hash'] - vivify_164: + vivify_170: set $P221, $P220["statementlist"] - unless_null $P221, vivify_165 + unless_null $P221, vivify_171 new $P221, "Undef" - vivify_165: + vivify_171: $P222 = $P221."ast"() store_lex "$mainline", $P222 .annotate 'line', 51 @@ -17949,10 +18321,10 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statementlist" :subid("23_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statementlist" :subid("23_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_249 .annotate 'line', 76 - .const 'Sub' $P263 = "24_1275511729.89077" + .const 'Sub' $P263 = "24_1275600017.58296" capture_lex $P263 new $P248, 'ExceptionHandler' set_addr $P248, control_247 @@ -17969,25 +18341,25 @@ NQP::Compiler - NQP compiler store_lex "$past", $P253 .annotate 'line', 78 find_lex $P255, "$/" - unless_null $P255, vivify_166 + unless_null $P255, vivify_172 $P255 = root_new ['parrot';'Hash'] - vivify_166: + vivify_172: set $P256, $P255["statement"] - unless_null $P256, vivify_167 + unless_null $P256, vivify_173 new $P256, "Undef" - vivify_167: + vivify_173: unless $P256, if_254_end .annotate 'line', 79 find_lex $P258, "$/" - unless_null $P258, vivify_168 + unless_null $P258, vivify_174 $P258 = root_new ['parrot';'Hash'] - vivify_168: + vivify_174: set $P259, $P258["statement"] - unless_null $P259, vivify_169 + unless_null $P259, vivify_175 new $P259, "Undef" - vivify_169: + vivify_175: defined $I260, $P259 - unless $I260, for_undef_170 + unless $I260, for_undef_176 iter $P257, $P259 new $P283, 'ExceptionHandler' set_addr $P283, loop282_handler @@ -17997,7 +18369,7 @@ NQP::Compiler - NQP compiler unless $P257, loop282_done shift $P261, $P257 loop282_redo: - .const 'Sub' $P263 = "24_1275511729.89077" + .const 'Sub' $P263 = "24_1275600017.58296" capture_lex $P263 $P263($P261) loop282_next: @@ -18010,7 +18382,7 @@ NQP::Compiler - NQP compiler eq $P284, 66, loop282_redo loop282_done: pop_eh - for_undef_170: + for_undef_176: if_254_end: .annotate 'line', 86 find_lex $P285, "$/" @@ -18027,7 +18399,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "_block262" :anon :subid("24_1275511729.89077") :outer("23_1275511729.89077") +.sub "_block262" :anon :subid("24_1275600017.58296") :outer("23_1275600017.58296") .param pmc param_265 .annotate 'line', 80 new $P264, "Undef" @@ -18038,34 +18410,34 @@ NQP::Compiler - NQP compiler store_lex "$ast", $P267 .annotate 'line', 81 find_lex $P269, "$ast" - unless_null $P269, vivify_171 + unless_null $P269, vivify_177 $P269 = root_new ['parrot';'Hash'] - vivify_171: + vivify_177: set $P270, $P269["sink"] - unless_null $P270, vivify_172 + unless_null $P270, vivify_178 new $P270, "Undef" - vivify_172: + vivify_178: defined $I271, $P270 unless $I271, if_268_end find_lex $P272, "$ast" - unless_null $P272, vivify_173 + unless_null $P272, vivify_179 $P272 = root_new ['parrot';'Hash'] - vivify_173: + vivify_179: set $P273, $P272["sink"] - unless_null $P273, vivify_174 + unless_null $P273, vivify_180 new $P273, "Undef" - vivify_174: + vivify_180: store_lex "$ast", $P273 if_268_end: .annotate 'line', 82 find_lex $P275, "$ast" - unless_null $P275, vivify_175 + unless_null $P275, vivify_181 $P275 = root_new ['parrot';'Hash'] - vivify_175: + vivify_181: set $P276, $P275["bareblock"] - unless_null $P276, vivify_176 + unless_null $P276, vivify_182 new $P276, "Undef" - vivify_176: + vivify_182: unless $P276, if_274_end find_lex $P277, "$ast" $P278 = "block_immediate"($P277) @@ -18081,12 +18453,12 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement" :subid("25_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement" :subid("25_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_292 .param pmc param_293 :optional .param int has_param_293 :opt_flag .annotate 'line', 89 - .const 'Sub' $P301 = "26_1275511729.89077" + .const 'Sub' $P301 = "26_1275600017.58296" capture_lex $P301 new $P291, 'ExceptionHandler' set_addr $P291, control_290 @@ -18094,10 +18466,10 @@ NQP::Compiler - NQP compiler push_eh $P291 .lex "self", self .lex "$/", param_292 - if has_param_293, optparam_177 + if has_param_293, optparam_183 new $P294, "Undef" set param_293, $P294 - optparam_177: + optparam_183: .lex "$key", param_293 .annotate 'line', 90 new $P295, "Undef" @@ -18106,23 +18478,23 @@ NQP::Compiler - NQP compiler find_lex $P296, "$past" .annotate 'line', 91 find_lex $P298, "$/" - unless_null $P298, vivify_178 + unless_null $P298, vivify_184 $P298 = root_new ['parrot';'Hash'] - vivify_178: + vivify_184: set $P299, $P298["EXPR"] - unless_null $P299, vivify_179 + unless_null $P299, vivify_185 new $P299, "Undef" - vivify_179: + vivify_185: if $P299, if_297 .annotate 'line', 102 find_lex $P339, "$/" - unless_null $P339, vivify_180 + unless_null $P339, vivify_186 $P339 = root_new ['parrot';'Hash'] - vivify_180: + vivify_186: set $P340, $P339["statement_control"] - unless_null $P340, vivify_181 + unless_null $P340, vivify_187 new $P340, "Undef" - vivify_181: + vivify_187: if $P340, if_338 .annotate 'line', 103 new $P344, "Integer" @@ -18132,20 +18504,20 @@ NQP::Compiler - NQP compiler if_338: .annotate 'line', 102 find_lex $P341, "$/" - unless_null $P341, vivify_182 + unless_null $P341, vivify_188 $P341 = root_new ['parrot';'Hash'] - vivify_182: + vivify_188: set $P342, $P341["statement_control"] - unless_null $P342, vivify_183 + unless_null $P342, vivify_189 new $P342, "Undef" - vivify_183: + vivify_189: $P343 = $P342."ast"() store_lex "$past", $P343 if_338_end: goto if_297_end if_297: .annotate 'line', 91 - .const 'Sub' $P301 = "26_1275511729.89077" + .const 'Sub' $P301 = "26_1275600017.58296" capture_lex $P301 $P301() if_297_end: @@ -18164,7 +18536,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "_block300" :anon :subid("26_1275511729.89077") :outer("25_1275511729.89077") +.sub "_block300" :anon :subid("26_1275600017.58296") :outer("25_1275600017.58296") .annotate 'line', 92 new $P302, "Undef" .lex "$mc", $P302 @@ -18173,41 +18545,41 @@ NQP::Compiler - NQP compiler .lex "$ml", $P303 .annotate 'line', 92 find_lex $P304, "$/" - unless_null $P304, vivify_184 + unless_null $P304, vivify_190 $P304 = root_new ['parrot';'Hash'] - vivify_184: + vivify_190: set $P305, $P304["statement_mod_cond"] - unless_null $P305, vivify_185 + unless_null $P305, vivify_191 $P305 = root_new ['parrot';'ResizablePMCArray'] - vivify_185: + vivify_191: set $P306, $P305[0] - unless_null $P306, vivify_186 + unless_null $P306, vivify_192 new $P306, "Undef" - vivify_186: + vivify_192: store_lex "$mc", $P306 .annotate 'line', 93 find_lex $P307, "$/" - unless_null $P307, vivify_187 + unless_null $P307, vivify_193 $P307 = root_new ['parrot';'Hash'] - vivify_187: + vivify_193: set $P308, $P307["statement_mod_loop"] - unless_null $P308, vivify_188 + unless_null $P308, vivify_194 $P308 = root_new ['parrot';'ResizablePMCArray'] - vivify_188: + vivify_194: set $P309, $P308[0] - unless_null $P309, vivify_189 + unless_null $P309, vivify_195 new $P309, "Undef" - vivify_189: + vivify_195: store_lex "$ml", $P309 .annotate 'line', 94 find_lex $P310, "$/" - unless_null $P310, vivify_190 + unless_null $P310, vivify_196 $P310 = root_new ['parrot';'Hash'] - vivify_190: + vivify_196: set $P311, $P310["EXPR"] - unless_null $P311, vivify_191 + unless_null $P311, vivify_197 new $P311, "Undef" - vivify_191: + vivify_197: $P312 = $P311."ast"() store_lex "$past", $P312 .annotate 'line', 95 @@ -18216,23 +18588,23 @@ NQP::Compiler - NQP compiler .annotate 'line', 96 get_hll_global $P315, ["PAST"], "Op" find_lex $P316, "$mc" - unless_null $P316, vivify_192 + unless_null $P316, vivify_198 $P316 = root_new ['parrot';'Hash'] - vivify_192: + vivify_198: set $P317, $P316["cond"] - unless_null $P317, vivify_193 + unless_null $P317, vivify_199 new $P317, "Undef" - vivify_193: + vivify_199: $P318 = $P317."ast"() find_lex $P319, "$past" find_lex $P320, "$mc" - unless_null $P320, vivify_194 + unless_null $P320, vivify_200 $P320 = root_new ['parrot';'Hash'] - vivify_194: + vivify_200: set $P321, $P320["sym"] - unless_null $P321, vivify_195 + unless_null $P321, vivify_201 new $P321, "Undef" - vivify_195: + vivify_201: set $S322, $P321 find_lex $P323, "$/" $P324 = $P315."new"($P318, $P319, $S322 :named("pasttype"), $P323 :named("node")) @@ -18247,23 +18619,23 @@ NQP::Compiler - NQP compiler .annotate 'line', 99 get_hll_global $P328, ["PAST"], "Op" find_lex $P329, "$ml" - unless_null $P329, vivify_196 + unless_null $P329, vivify_202 $P329 = root_new ['parrot';'Hash'] - vivify_196: + vivify_202: set $P330, $P329["cond"] - unless_null $P330, vivify_197 + unless_null $P330, vivify_203 new $P330, "Undef" - vivify_197: + vivify_203: $P331 = $P330."ast"() find_lex $P332, "$past" find_lex $P333, "$ml" - unless_null $P333, vivify_198 + unless_null $P333, vivify_204 $P333 = root_new ['parrot';'Hash'] - vivify_198: + vivify_204: set $P334, $P333["sym"] - unless_null $P334, vivify_199 + unless_null $P334, vivify_205 new $P334, "Undef" - vivify_199: + vivify_205: set $S335, $P334 find_lex $P336, "$/" $P337 = $P328."new"($P331, $P332, $S335 :named("pasttype"), $P336 :named("node")) @@ -18277,7 +18649,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "xblock" :subid("27_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "xblock" :subid("27_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_352 .annotate 'line', 107 new $P351, 'ExceptionHandler' @@ -18290,22 +18662,22 @@ NQP::Compiler - NQP compiler find_lex $P353, "$/" get_hll_global $P354, ["PAST"], "Op" find_lex $P355, "$/" - unless_null $P355, vivify_200 + unless_null $P355, vivify_206 $P355 = root_new ['parrot';'Hash'] - vivify_200: + vivify_206: set $P356, $P355["EXPR"] - unless_null $P356, vivify_201 + unless_null $P356, vivify_207 new $P356, "Undef" - vivify_201: + vivify_207: $P357 = $P356."ast"() find_lex $P358, "$/" - unless_null $P358, vivify_202 + unless_null $P358, vivify_208 $P358 = root_new ['parrot';'Hash'] - vivify_202: + vivify_208: set $P359, $P358["pblock"] - unless_null $P359, vivify_203 + unless_null $P359, vivify_209 new $P359, "Undef" - vivify_203: + vivify_209: $P360 = $P359."ast"() find_lex $P361, "$/" $P362 = $P354."new"($P357, $P360, "if" :named("pasttype"), $P361 :named("node")) @@ -18321,7 +18693,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "pblock" :subid("28_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "pblock" :subid("28_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_368 .annotate 'line', 111 new $P367, 'ExceptionHandler' @@ -18333,13 +18705,13 @@ NQP::Compiler - NQP compiler .annotate 'line', 112 find_lex $P369, "$/" find_lex $P370, "$/" - unless_null $P370, vivify_204 + unless_null $P370, vivify_210 $P370 = root_new ['parrot';'Hash'] - vivify_204: + vivify_210: set $P371, $P370["blockoid"] - unless_null $P371, vivify_205 + unless_null $P371, vivify_211 new $P371, "Undef" - vivify_205: + vivify_211: $P372 = $P371."ast"() $P373 = $P369."!make"($P372) .annotate 'line', 111 @@ -18353,7 +18725,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "block" :subid("29_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "block" :subid("29_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_378 .annotate 'line', 115 new $P377, 'ExceptionHandler' @@ -18365,13 +18737,13 @@ NQP::Compiler - NQP compiler .annotate 'line', 116 find_lex $P379, "$/" find_lex $P380, "$/" - unless_null $P380, vivify_206 + unless_null $P380, vivify_212 $P380 = root_new ['parrot';'Hash'] - vivify_206: + vivify_212: set $P381, $P380["blockoid"] - unless_null $P381, vivify_207 + unless_null $P381, vivify_213 new $P381, "Undef" - vivify_207: + vivify_213: $P382 = $P381."ast"() $P383 = $P379."!make"($P382) .annotate 'line', 115 @@ -18385,7 +18757,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "blockoid" :subid("30_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "blockoid" :subid("30_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_388 .annotate 'line', 119 new $P387, 'ExceptionHandler' @@ -18402,13 +18774,13 @@ NQP::Compiler - NQP compiler .lex "$BLOCK", $P390 .annotate 'line', 120 find_lex $P391, "$/" - unless_null $P391, vivify_208 + unless_null $P391, vivify_214 $P391 = root_new ['parrot';'Hash'] - vivify_208: + vivify_214: set $P392, $P391["statementlist"] - unless_null $P392, vivify_209 + unless_null $P392, vivify_215 new $P392, "Undef" - vivify_209: + vivify_215: $P393 = $P392."ast"() store_lex "$past", $P393 .annotate 'line', 121 @@ -18441,7 +18813,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "newpad" :subid("31_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "newpad" :subid("31_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_408 .annotate 'line', 128 new $P407, 'ExceptionHandler' @@ -18452,10 +18824,10 @@ NQP::Compiler - NQP compiler .lex "$/", param_408 .annotate 'line', 129 get_global $P409, "@BLOCK" - unless_null $P409, vivify_210 + unless_null $P409, vivify_216 $P409 = root_new ['parrot';'ResizablePMCArray'] set_global "@BLOCK", $P409 - vivify_210: + vivify_216: .annotate 'line', 128 get_global $P410, "@BLOCK" .annotate 'line', 130 @@ -18476,7 +18848,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "outerctx" :subid("32_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "outerctx" :subid("32_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_421 .annotate 'line', 133 new $P420, 'ExceptionHandler' @@ -18487,22 +18859,22 @@ NQP::Compiler - NQP compiler .lex "$/", param_421 .annotate 'line', 134 get_global $P422, "@BLOCK" - unless_null $P422, vivify_211 + unless_null $P422, vivify_217 $P422 = root_new ['parrot';'ResizablePMCArray'] set_global "@BLOCK", $P422 - vivify_211: + vivify_217: .annotate 'line', 133 get_global $P423, "@BLOCK" .annotate 'line', 135 find_lex $P424, "self" get_global $P425, "@BLOCK" - unless_null $P425, vivify_212 + unless_null $P425, vivify_218 $P425 = root_new ['parrot';'ResizablePMCArray'] - vivify_212: + vivify_218: set $P426, $P425[0] - unless_null $P426, vivify_213 + unless_null $P426, vivify_219 new $P426, "Undef" - vivify_213: + vivify_219: $P427 = $P424."SET_BLOCK_OUTER_CTX"($P426) .annotate 'line', 133 .return ($P427) @@ -18515,10 +18887,10 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_control:sym" :subid("33_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_control:sym" :subid("33_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_432 .annotate 'line', 140 - .const 'Sub' $P460 = "34_1275511729.89077" + .const 'Sub' $P460 = "34_1275600017.58296" capture_lex $P460 new $P431, 'ExceptionHandler' set_addr $P431, control_430 @@ -18534,13 +18906,13 @@ NQP::Compiler - NQP compiler .lex "$past", $P434 .annotate 'line', 141 find_lex $P435, "$/" - unless_null $P435, vivify_214 + unless_null $P435, vivify_220 $P435 = root_new ['parrot';'Hash'] - vivify_214: + vivify_220: set $P436, $P435["xblock"] - unless_null $P436, vivify_215 + unless_null $P436, vivify_221 new $P436, "Undef" - vivify_215: + vivify_221: set $N437, $P436 new $P438, 'Float' set $P438, $N437 @@ -18550,44 +18922,44 @@ NQP::Compiler - NQP compiler find_lex $P440, "$count" set $I441, $P440 find_lex $P442, "$/" - unless_null $P442, vivify_216 + unless_null $P442, vivify_222 $P442 = root_new ['parrot';'Hash'] - vivify_216: + vivify_222: set $P443, $P442["xblock"] - unless_null $P443, vivify_217 + unless_null $P443, vivify_223 $P443 = root_new ['parrot';'ResizablePMCArray'] - vivify_217: + vivify_223: set $P444, $P443[$I441] - unless_null $P444, vivify_218 + unless_null $P444, vivify_224 new $P444, "Undef" - vivify_218: + vivify_224: $P445 = $P444."ast"() $P446 = "xblock_immediate"($P445) store_lex "$past", $P446 .annotate 'line', 143 find_lex $P448, "$/" - unless_null $P448, vivify_219 + unless_null $P448, vivify_225 $P448 = root_new ['parrot';'Hash'] - vivify_219: + vivify_225: set $P449, $P448["else"] - unless_null $P449, vivify_220 + unless_null $P449, vivify_226 new $P449, "Undef" - vivify_220: + vivify_226: unless $P449, if_447_end .annotate 'line', 144 find_lex $P450, "$past" find_lex $P451, "$/" - unless_null $P451, vivify_221 + unless_null $P451, vivify_227 $P451 = root_new ['parrot';'Hash'] - vivify_221: + vivify_227: set $P452, $P451["else"] - unless_null $P452, vivify_222 + unless_null $P452, vivify_228 $P452 = root_new ['parrot';'ResizablePMCArray'] - vivify_222: + vivify_228: set $P453, $P452[0] - unless_null $P453, vivify_223 + unless_null $P453, vivify_229 new $P453, "Undef" - vivify_223: + vivify_229: $P454 = $P453."ast"() $P455 = "block_immediate"($P454) $P450."push"($P455) @@ -18603,7 +18975,7 @@ NQP::Compiler - NQP compiler isgt $I458, $N457, 0.0 unless $I458, loop475_done loop475_redo: - .const 'Sub' $P460 = "34_1275511729.89077" + .const 'Sub' $P460 = "34_1275600017.58296" capture_lex $P460 $P460() loop475_next: @@ -18631,7 +19003,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "_block459" :anon :subid("34_1275511729.89077") :outer("33_1275511729.89077") +.sub "_block459" :anon :subid("34_1275600017.58296") :outer("33_1275600017.58296") .annotate 'line', 149 new $P461, "Undef" .lex "$else", $P461 @@ -18646,17 +19018,17 @@ NQP::Compiler - NQP compiler find_lex $P465, "$count" set $I466, $P465 find_lex $P467, "$/" - unless_null $P467, vivify_224 + unless_null $P467, vivify_230 $P467 = root_new ['parrot';'Hash'] - vivify_224: + vivify_230: set $P468, $P467["xblock"] - unless_null $P468, vivify_225 + unless_null $P468, vivify_231 $P468 = root_new ['parrot';'ResizablePMCArray'] - vivify_225: + vivify_231: set $P469, $P468[$I466] - unless_null $P469, vivify_226 + unless_null $P469, vivify_232 new $P469, "Undef" - vivify_226: + vivify_232: $P470 = $P469."ast"() $P471 = "xblock_immediate"($P470) store_lex "$past", $P471 @@ -18670,7 +19042,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_control:sym" :subid("35_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_control:sym" :subid("35_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_485 .annotate 'line', 156 new $P484, 'ExceptionHandler' @@ -18683,13 +19055,13 @@ NQP::Compiler - NQP compiler new $P486, "Undef" .lex "$past", $P486 find_lex $P487, "$/" - unless_null $P487, vivify_227 + unless_null $P487, vivify_233 $P487 = root_new ['parrot';'Hash'] - vivify_227: + vivify_233: set $P488, $P487["xblock"] - unless_null $P488, vivify_228 + unless_null $P488, vivify_234 new $P488, "Undef" - vivify_228: + vivify_234: $P489 = $P488."ast"() $P490 = "xblock_immediate"($P489) store_lex "$past", $P490 @@ -18711,7 +19083,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_control:sym" :subid("36_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_control:sym" :subid("36_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_499 .annotate 'line', 162 new $P498, 'ExceptionHandler' @@ -18724,26 +19096,26 @@ NQP::Compiler - NQP compiler new $P500, "Undef" .lex "$past", $P500 find_lex $P501, "$/" - unless_null $P501, vivify_229 + unless_null $P501, vivify_235 $P501 = root_new ['parrot';'Hash'] - vivify_229: + vivify_235: set $P502, $P501["xblock"] - unless_null $P502, vivify_230 + unless_null $P502, vivify_236 new $P502, "Undef" - vivify_230: + vivify_236: $P503 = $P502."ast"() $P504 = "xblock_immediate"($P503) store_lex "$past", $P504 .annotate 'line', 164 find_lex $P505, "$past" find_lex $P506, "$/" - unless_null $P506, vivify_231 + unless_null $P506, vivify_237 $P506 = root_new ['parrot';'Hash'] - vivify_231: + vivify_237: set $P507, $P506["sym"] - unless_null $P507, vivify_232 + unless_null $P507, vivify_238 new $P507, "Undef" - vivify_232: + vivify_238: set $S508, $P507 $P505."pasttype"($S508) .annotate 'line', 165 @@ -18761,7 +19133,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_control:sym" :subid("37_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_control:sym" :subid("37_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_516 .annotate 'line', 168 new $P515, 'ExceptionHandler' @@ -18780,46 +19152,46 @@ NQP::Compiler - NQP compiler new $P519, "String" assign $P519, "repeat_" find_lex $P520, "$/" - unless_null $P520, vivify_233 + unless_null $P520, vivify_239 $P520 = root_new ['parrot';'Hash'] - vivify_233: + vivify_239: set $P521, $P520["wu"] - unless_null $P521, vivify_234 + unless_null $P521, vivify_240 new $P521, "Undef" - vivify_234: + vivify_240: set $S522, $P521 concat $P523, $P519, $S522 store_lex "$pasttype", $P523 find_lex $P524, "$past" .annotate 'line', 171 find_lex $P526, "$/" - unless_null $P526, vivify_235 + unless_null $P526, vivify_241 $P526 = root_new ['parrot';'Hash'] - vivify_235: + vivify_241: set $P527, $P526["xblock"] - unless_null $P527, vivify_236 + unless_null $P527, vivify_242 new $P527, "Undef" - vivify_236: + vivify_242: if $P527, if_525 .annotate 'line', 176 get_hll_global $P534, ["PAST"], "Op" find_lex $P535, "$/" - unless_null $P535, vivify_237 + unless_null $P535, vivify_243 $P535 = root_new ['parrot';'Hash'] - vivify_237: + vivify_243: set $P536, $P535["EXPR"] - unless_null $P536, vivify_238 + unless_null $P536, vivify_244 new $P536, "Undef" - vivify_238: + vivify_244: $P537 = $P536."ast"() find_lex $P538, "$/" - unless_null $P538, vivify_239 + unless_null $P538, vivify_245 $P538 = root_new ['parrot';'Hash'] - vivify_239: + vivify_245: set $P539, $P538["pblock"] - unless_null $P539, vivify_240 + unless_null $P539, vivify_246 new $P539, "Undef" - vivify_240: + vivify_246: $P540 = $P539."ast"() $P541 = "block_immediate"($P540) find_lex $P542, "$pasttype" @@ -18831,13 +19203,13 @@ NQP::Compiler - NQP compiler if_525: .annotate 'line', 172 find_lex $P528, "$/" - unless_null $P528, vivify_241 + unless_null $P528, vivify_247 $P528 = root_new ['parrot';'Hash'] - vivify_241: + vivify_247: set $P529, $P528["xblock"] - unless_null $P529, vivify_242 + unless_null $P529, vivify_248 new $P529, "Undef" - vivify_242: + vivify_248: $P530 = $P529."ast"() $P531 = "xblock_immediate"($P530) store_lex "$past", $P531 @@ -18861,7 +19233,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_control:sym" :subid("38_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_control:sym" :subid("38_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_552 .annotate 'line', 182 new $P551, 'ExceptionHandler' @@ -18878,13 +19250,13 @@ NQP::Compiler - NQP compiler .lex "$block", $P554 .annotate 'line', 183 find_lex $P555, "$/" - unless_null $P555, vivify_243 + unless_null $P555, vivify_249 $P555 = root_new ['parrot';'Hash'] - vivify_243: + vivify_249: set $P556, $P555["xblock"] - unless_null $P556, vivify_244 + unless_null $P556, vivify_250 new $P556, "Undef" - vivify_244: + vivify_250: $P557 = $P556."ast"() store_lex "$past", $P557 .annotate 'line', 184 @@ -18892,13 +19264,13 @@ NQP::Compiler - NQP compiler $P558."pasttype"("for") .annotate 'line', 185 find_lex $P559, "$past" - unless_null $P559, vivify_245 + unless_null $P559, vivify_251 $P559 = root_new ['parrot';'ResizablePMCArray'] - vivify_245: + vivify_251: set $P560, $P559[1] - unless_null $P560, vivify_246 + unless_null $P560, vivify_252 new $P560, "Undef" - vivify_246: + vivify_252: store_lex "$block", $P560 .annotate 'line', 186 find_lex $P562, "$block" @@ -18906,13 +19278,13 @@ NQP::Compiler - NQP compiler if $P563, unless_561_end .annotate 'line', 187 find_lex $P564, "$block" - unless_null $P564, vivify_247 + unless_null $P564, vivify_253 $P564 = root_new ['parrot';'ResizablePMCArray'] - vivify_247: + vivify_253: set $P565, $P564[0] - unless_null $P565, vivify_248 + unless_null $P565, vivify_254 new $P565, "Undef" - vivify_248: + vivify_254: get_hll_global $P566, ["PAST"], "Var" $P567 = $P566."new"("$_" :named("name"), "parameter" :named("scope")) $P565."push"($P567) @@ -18941,7 +19313,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_control:sym" :subid("39_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_control:sym" :subid("39_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_578 .annotate 'line', 195 new $P577, 'ExceptionHandler' @@ -18954,13 +19326,13 @@ NQP::Compiler - NQP compiler find_lex $P579, "$/" get_hll_global $P580, ["PAST"], "Op" find_lex $P581, "$/" - unless_null $P581, vivify_249 + unless_null $P581, vivify_255 $P581 = root_new ['parrot';'Hash'] - vivify_249: + vivify_255: set $P582, $P581["EXPR"] - unless_null $P582, vivify_250 + unless_null $P582, vivify_256 new $P582, "Undef" - vivify_250: + vivify_256: $P583 = $P582."ast"() find_lex $P584, "$/" $P585 = $P580."new"($P583, "return" :named("pasttype"), $P584 :named("node")) @@ -18976,7 +19348,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_control:sym" :subid("40_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_control:sym" :subid("40_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_591 .annotate 'line', 199 new $P590, 'ExceptionHandler' @@ -18989,13 +19361,13 @@ NQP::Compiler - NQP compiler new $P592, "Undef" .lex "$block", $P592 find_lex $P593, "$/" - unless_null $P593, vivify_251 + unless_null $P593, vivify_257 $P593 = root_new ['parrot';'Hash'] - vivify_251: + vivify_257: set $P594, $P593["block"] - unless_null $P594, vivify_252 + unless_null $P594, vivify_258 new $P594, "Undef" - vivify_252: + vivify_258: $P595 = $P594."ast"() store_lex "$block", $P595 .annotate 'line', 201 @@ -19004,18 +19376,18 @@ NQP::Compiler - NQP compiler "push_block_handler"($P596, $P597) .annotate 'line', 202 get_global $P598, "@BLOCK" - unless_null $P598, vivify_253 + unless_null $P598, vivify_259 $P598 = root_new ['parrot';'ResizablePMCArray'] - vivify_253: + vivify_259: set $P599, $P598[0] - unless_null $P599, vivify_254 + unless_null $P599, vivify_260 new $P599, "Undef" - vivify_254: + vivify_260: $P600 = $P599."handlers"() set $P601, $P600[0] - unless_null $P601, vivify_255 + unless_null $P601, vivify_261 new $P601, "Undef" - vivify_255: + vivify_261: $P601."handle_types_except"("CONTROL") .annotate 'line', 203 find_lex $P602, "$/" @@ -19034,7 +19406,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_control:sym" :subid("41_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_control:sym" :subid("41_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_611 .annotate 'line', 206 new $P610, 'ExceptionHandler' @@ -19047,13 +19419,13 @@ NQP::Compiler - NQP compiler new $P612, "Undef" .lex "$block", $P612 find_lex $P613, "$/" - unless_null $P613, vivify_256 + unless_null $P613, vivify_262 $P613 = root_new ['parrot';'Hash'] - vivify_256: + vivify_262: set $P614, $P613["block"] - unless_null $P614, vivify_257 + unless_null $P614, vivify_263 new $P614, "Undef" - vivify_257: + vivify_263: $P615 = $P614."ast"() store_lex "$block", $P615 .annotate 'line', 208 @@ -19062,18 +19434,18 @@ NQP::Compiler - NQP compiler "push_block_handler"($P616, $P617) .annotate 'line', 209 get_global $P618, "@BLOCK" - unless_null $P618, vivify_258 + unless_null $P618, vivify_264 $P618 = root_new ['parrot';'ResizablePMCArray'] - vivify_258: + vivify_264: set $P619, $P618[0] - unless_null $P619, vivify_259 + unless_null $P619, vivify_265 new $P619, "Undef" - vivify_259: + vivify_265: $P620 = $P619."handlers"() set $P621, $P620[0] - unless_null $P621, vivify_260 + unless_null $P621, vivify_266 new $P621, "Undef" - vivify_260: + vivify_266: $P621."handle_types"("CONTROL") .annotate 'line', 210 find_lex $P622, "$/" @@ -19092,7 +19464,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_prefix:sym" :subid("42_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_prefix:sym" :subid("42_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_632 .annotate 'line', 250 new $P631, 'ExceptionHandler' @@ -19103,22 +19475,22 @@ NQP::Compiler - NQP compiler .lex "$/", param_632 .annotate 'line', 251 get_global $P633, "@BLOCK" - unless_null $P633, vivify_261 + unless_null $P633, vivify_267 $P633 = root_new ['parrot';'ResizablePMCArray'] - vivify_261: + vivify_267: set $P634, $P633[0] - unless_null $P634, vivify_262 + unless_null $P634, vivify_268 new $P634, "Undef" - vivify_262: + vivify_268: $P635 = $P634."loadinit"() find_lex $P636, "$/" - unless_null $P636, vivify_263 + unless_null $P636, vivify_269 $P636 = root_new ['parrot';'Hash'] - vivify_263: + vivify_269: set $P637, $P636["blorst"] - unless_null $P637, vivify_264 + unless_null $P637, vivify_270 new $P637, "Undef" - vivify_264: + vivify_270: $P638 = $P637."ast"() $P635."push"($P638) .annotate 'line', 252 @@ -19138,7 +19510,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_prefix:sym" :subid("43_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_prefix:sym" :subid("43_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_648 .annotate 'line', 255 new $P647, 'ExceptionHandler' @@ -19151,13 +19523,13 @@ NQP::Compiler - NQP compiler new $P649, "Undef" .lex "$past", $P649 find_lex $P650, "$/" - unless_null $P650, vivify_265 + unless_null $P650, vivify_271 $P650 = root_new ['parrot';'Hash'] - vivify_265: + vivify_271: set $P651, $P650["blorst"] - unless_null $P651, vivify_266 + unless_null $P651, vivify_272 new $P651, "Undef" - vivify_266: + vivify_272: $P652 = $P651."ast"() store_lex "$past", $P652 .annotate 'line', 257 @@ -19215,7 +19587,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "blorst" :subid("44_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "blorst" :subid("44_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_683 .annotate 'line', 278 new $P682, 'ExceptionHandler' @@ -19228,36 +19600,36 @@ NQP::Compiler - NQP compiler find_lex $P684, "$/" .annotate 'line', 280 find_lex $P687, "$/" - unless_null $P687, vivify_267 + unless_null $P687, vivify_273 $P687 = root_new ['parrot';'Hash'] - vivify_267: + vivify_273: set $P688, $P687["block"] - unless_null $P688, vivify_268 + unless_null $P688, vivify_274 new $P688, "Undef" - vivify_268: + vivify_274: if $P688, if_686 .annotate 'line', 281 find_lex $P693, "$/" - unless_null $P693, vivify_269 + unless_null $P693, vivify_275 $P693 = root_new ['parrot';'Hash'] - vivify_269: + vivify_275: set $P694, $P693["statement"] - unless_null $P694, vivify_270 + unless_null $P694, vivify_276 new $P694, "Undef" - vivify_270: + vivify_276: $P695 = $P694."ast"() set $P685, $P695 .annotate 'line', 280 goto if_686_end if_686: find_lex $P689, "$/" - unless_null $P689, vivify_271 + unless_null $P689, vivify_277 $P689 = root_new ['parrot';'Hash'] - vivify_271: + vivify_277: set $P690, $P689["block"] - unless_null $P690, vivify_272 + unless_null $P690, vivify_278 new $P690, "Undef" - vivify_272: + vivify_278: $P691 = $P690."ast"() $P692 = "block_immediate"($P691) set $P685, $P692 @@ -19274,7 +19646,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_mod_cond:sym" :subid("45_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_mod_cond:sym" :subid("45_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_701 .annotate 'line', 286 new $P700, 'ExceptionHandler' @@ -19285,13 +19657,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_701 find_lex $P702, "$/" find_lex $P703, "$/" - unless_null $P703, vivify_273 + unless_null $P703, vivify_279 $P703 = root_new ['parrot';'Hash'] - vivify_273: + vivify_279: set $P704, $P703["cond"] - unless_null $P704, vivify_274 + unless_null $P704, vivify_280 new $P704, "Undef" - vivify_274: + vivify_280: $P705 = $P704."ast"() $P706 = $P702."!make"($P705) .return ($P706) @@ -19304,7 +19676,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_mod_cond:sym" :subid("46_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_mod_cond:sym" :subid("46_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_711 .annotate 'line', 287 new $P710, 'ExceptionHandler' @@ -19315,13 +19687,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_711 find_lex $P712, "$/" find_lex $P713, "$/" - unless_null $P713, vivify_275 + unless_null $P713, vivify_281 $P713 = root_new ['parrot';'Hash'] - vivify_275: + vivify_281: set $P714, $P713["cond"] - unless_null $P714, vivify_276 + unless_null $P714, vivify_282 new $P714, "Undef" - vivify_276: + vivify_282: $P715 = $P714."ast"() $P716 = $P712."!make"($P715) .return ($P716) @@ -19334,7 +19706,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_mod_loop:sym" :subid("47_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_mod_loop:sym" :subid("47_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_721 .annotate 'line', 289 new $P720, 'ExceptionHandler' @@ -19345,13 +19717,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_721 find_lex $P722, "$/" find_lex $P723, "$/" - unless_null $P723, vivify_277 + unless_null $P723, vivify_283 $P723 = root_new ['parrot';'Hash'] - vivify_277: + vivify_283: set $P724, $P723["cond"] - unless_null $P724, vivify_278 + unless_null $P724, vivify_284 new $P724, "Undef" - vivify_278: + vivify_284: $P725 = $P724."ast"() $P726 = $P722."!make"($P725) .return ($P726) @@ -19364,7 +19736,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "statement_mod_loop:sym" :subid("48_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "statement_mod_loop:sym" :subid("48_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_731 .annotate 'line', 290 new $P730, 'ExceptionHandler' @@ -19375,13 +19747,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_731 find_lex $P732, "$/" find_lex $P733, "$/" - unless_null $P733, vivify_279 + unless_null $P733, vivify_285 $P733 = root_new ['parrot';'Hash'] - vivify_279: + vivify_285: set $P734, $P733["cond"] - unless_null $P734, vivify_280 + unless_null $P734, vivify_286 new $P734, "Undef" - vivify_280: + vivify_286: $P735 = $P734."ast"() $P736 = $P732."!make"($P735) .return ($P736) @@ -19394,7 +19766,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("49_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "term:sym" :subid("49_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_741 .annotate 'line', 294 new $P740, 'ExceptionHandler' @@ -19405,13 +19777,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_741 find_lex $P742, "$/" find_lex $P743, "$/" - unless_null $P743, vivify_281 + unless_null $P743, vivify_287 $P743 = root_new ['parrot';'Hash'] - vivify_281: + vivify_287: set $P744, $P743["fatarrow"] - unless_null $P744, vivify_282 + unless_null $P744, vivify_288 new $P744, "Undef" - vivify_282: + vivify_288: $P745 = $P744."ast"() $P746 = $P742."!make"($P745) .return ($P746) @@ -19424,7 +19796,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("50_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "term:sym" :subid("50_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_751 .annotate 'line', 295 new $P750, 'ExceptionHandler' @@ -19435,13 +19807,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_751 find_lex $P752, "$/" find_lex $P753, "$/" - unless_null $P753, vivify_283 + unless_null $P753, vivify_289 $P753 = root_new ['parrot';'Hash'] - vivify_283: + vivify_289: set $P754, $P753["colonpair"] - unless_null $P754, vivify_284 + unless_null $P754, vivify_290 new $P754, "Undef" - vivify_284: + vivify_290: $P755 = $P754."ast"() $P756 = $P752."!make"($P755) .return ($P756) @@ -19454,7 +19826,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("51_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "term:sym" :subid("51_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_761 .annotate 'line', 296 new $P760, 'ExceptionHandler' @@ -19465,13 +19837,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_761 find_lex $P762, "$/" find_lex $P763, "$/" - unless_null $P763, vivify_285 + unless_null $P763, vivify_291 $P763 = root_new ['parrot';'Hash'] - vivify_285: + vivify_291: set $P764, $P763["variable"] - unless_null $P764, vivify_286 + unless_null $P764, vivify_292 new $P764, "Undef" - vivify_286: + vivify_292: $P765 = $P764."ast"() $P766 = $P762."!make"($P765) .return ($P766) @@ -19484,7 +19856,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("52_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "term:sym" :subid("52_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_771 .annotate 'line', 297 new $P770, 'ExceptionHandler' @@ -19495,13 +19867,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_771 find_lex $P772, "$/" find_lex $P773, "$/" - unless_null $P773, vivify_287 + unless_null $P773, vivify_293 $P773 = root_new ['parrot';'Hash'] - vivify_287: + vivify_293: set $P774, $P773["package_declarator"] - unless_null $P774, vivify_288 + unless_null $P774, vivify_294 new $P774, "Undef" - vivify_288: + vivify_294: $P775 = $P774."ast"() $P776 = $P772."!make"($P775) .return ($P776) @@ -19514,7 +19886,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("53_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "term:sym" :subid("53_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_781 .annotate 'line', 298 new $P780, 'ExceptionHandler' @@ -19525,13 +19897,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_781 find_lex $P782, "$/" find_lex $P783, "$/" - unless_null $P783, vivify_289 + unless_null $P783, vivify_295 $P783 = root_new ['parrot';'Hash'] - vivify_289: + vivify_295: set $P784, $P783["scope_declarator"] - unless_null $P784, vivify_290 + unless_null $P784, vivify_296 new $P784, "Undef" - vivify_290: + vivify_296: $P785 = $P784."ast"() $P786 = $P782."!make"($P785) .return ($P786) @@ -19544,7 +19916,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("54_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "term:sym" :subid("54_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_791 .annotate 'line', 299 new $P790, 'ExceptionHandler' @@ -19555,13 +19927,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_791 find_lex $P792, "$/" find_lex $P793, "$/" - unless_null $P793, vivify_291 + unless_null $P793, vivify_297 $P793 = root_new ['parrot';'Hash'] - vivify_291: + vivify_297: set $P794, $P793["routine_declarator"] - unless_null $P794, vivify_292 + unless_null $P794, vivify_298 new $P794, "Undef" - vivify_292: + vivify_298: $P795 = $P794."ast"() $P796 = $P792."!make"($P795) .return ($P796) @@ -19574,7 +19946,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("55_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "term:sym" :subid("55_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_801 .annotate 'line', 300 new $P800, 'ExceptionHandler' @@ -19585,13 +19957,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_801 find_lex $P802, "$/" find_lex $P803, "$/" - unless_null $P803, vivify_293 + unless_null $P803, vivify_299 $P803 = root_new ['parrot';'Hash'] - vivify_293: + vivify_299: set $P804, $P803["regex_declarator"] - unless_null $P804, vivify_294 + unless_null $P804, vivify_300 new $P804, "Undef" - vivify_294: + vivify_300: $P805 = $P804."ast"() $P806 = $P802."!make"($P805) .return ($P806) @@ -19604,7 +19976,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("56_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "term:sym" :subid("56_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_811 .annotate 'line', 301 new $P810, 'ExceptionHandler' @@ -19615,13 +19987,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_811 find_lex $P812, "$/" find_lex $P813, "$/" - unless_null $P813, vivify_295 + unless_null $P813, vivify_301 $P813 = root_new ['parrot';'Hash'] - vivify_295: + vivify_301: set $P814, $P813["statement_prefix"] - unless_null $P814, vivify_296 + unless_null $P814, vivify_302 new $P814, "Undef" - vivify_296: + vivify_302: $P815 = $P814."ast"() $P816 = $P812."!make"($P815) .return ($P816) @@ -19634,7 +20006,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("57_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "term:sym" :subid("57_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_821 .annotate 'line', 302 new $P820, 'ExceptionHandler' @@ -19645,13 +20017,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_821 find_lex $P822, "$/" find_lex $P823, "$/" - unless_null $P823, vivify_297 + unless_null $P823, vivify_303 $P823 = root_new ['parrot';'Hash'] - vivify_297: + vivify_303: set $P824, $P823["pblock"] - unless_null $P824, vivify_298 + unless_null $P824, vivify_304 new $P824, "Undef" - vivify_298: + vivify_304: $P825 = $P824."ast"() $P826 = $P822."!make"($P825) .return ($P826) @@ -19664,7 +20036,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "fatarrow" :subid("58_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "fatarrow" :subid("58_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_831 .annotate 'line', 304 new $P830, 'ExceptionHandler' @@ -19677,25 +20049,25 @@ NQP::Compiler - NQP compiler new $P832, "Undef" .lex "$past", $P832 find_lex $P833, "$/" - unless_null $P833, vivify_299 + unless_null $P833, vivify_305 $P833 = root_new ['parrot';'Hash'] - vivify_299: + vivify_305: set $P834, $P833["val"] - unless_null $P834, vivify_300 + unless_null $P834, vivify_306 new $P834, "Undef" - vivify_300: + vivify_306: $P835 = $P834."ast"() store_lex "$past", $P835 .annotate 'line', 306 find_lex $P836, "$past" find_lex $P837, "$/" - unless_null $P837, vivify_301 + unless_null $P837, vivify_307 $P837 = root_new ['parrot';'Hash'] - vivify_301: + vivify_307: set $P838, $P837["key"] - unless_null $P838, vivify_302 + unless_null $P838, vivify_308 new $P838, "Undef" - vivify_302: + vivify_308: $P839 = $P838."Str"() $P836."named"($P839) .annotate 'line', 307 @@ -19713,7 +20085,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "colonpair" :subid("59_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "colonpair" :subid("59_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_847 .annotate 'line', 310 new $P846, 'ExceptionHandler' @@ -19727,24 +20099,24 @@ NQP::Compiler - NQP compiler .lex "$past", $P848 .annotate 'line', 312 find_lex $P851, "$/" - unless_null $P851, vivify_303 + unless_null $P851, vivify_309 $P851 = root_new ['parrot';'Hash'] - vivify_303: + vivify_309: set $P852, $P851["circumfix"] - unless_null $P852, vivify_304 + unless_null $P852, vivify_310 new $P852, "Undef" - vivify_304: + vivify_310: if $P852, if_850 .annotate 'line', 313 get_hll_global $P857, ["PAST"], "Val" find_lex $P858, "$/" - unless_null $P858, vivify_305 + unless_null $P858, vivify_311 $P858 = root_new ['parrot';'Hash'] - vivify_305: + vivify_311: set $P859, $P858["not"] - unless_null $P859, vivify_306 + unless_null $P859, vivify_312 new $P859, "Undef" - vivify_306: + vivify_312: isfalse $I860, $P859 $P861 = $P857."new"($I860 :named("value")) set $P849, $P861 @@ -19752,17 +20124,17 @@ NQP::Compiler - NQP compiler goto if_850_end if_850: find_lex $P853, "$/" - unless_null $P853, vivify_307 + unless_null $P853, vivify_313 $P853 = root_new ['parrot';'Hash'] - vivify_307: + vivify_313: set $P854, $P853["circumfix"] - unless_null $P854, vivify_308 + unless_null $P854, vivify_314 $P854 = root_new ['parrot';'ResizablePMCArray'] - vivify_308: + vivify_314: set $P855, $P854[0] - unless_null $P855, vivify_309 + unless_null $P855, vivify_315 new $P855, "Undef" - vivify_309: + vivify_315: $P856 = $P855."ast"() set $P849, $P856 if_850_end: @@ -19770,13 +20142,13 @@ NQP::Compiler - NQP compiler .annotate 'line', 314 find_lex $P862, "$past" find_lex $P863, "$/" - unless_null $P863, vivify_310 + unless_null $P863, vivify_316 $P863 = root_new ['parrot';'Hash'] - vivify_310: + vivify_316: set $P864, $P863["identifier"] - unless_null $P864, vivify_311 + unless_null $P864, vivify_317 new $P864, "Undef" - vivify_311: + vivify_317: set $S865, $P864 $P862."named"($S865) .annotate 'line', 315 @@ -19794,10 +20166,10 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "variable" :subid("60_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "variable" :subid("60_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_873 .annotate 'line', 318 - .const 'Sub' $P886 = "61_1275511729.89077" + .const 'Sub' $P886 = "61_1275600017.58296" capture_lex $P886 new $P872, 'ExceptionHandler' set_addr $P872, control_871 @@ -19812,29 +20184,29 @@ NQP::Compiler - NQP compiler find_lex $P875, "$past" .annotate 'line', 320 find_lex $P877, "$/" - unless_null $P877, vivify_312 + unless_null $P877, vivify_318 $P877 = root_new ['parrot';'Hash'] - vivify_312: + vivify_318: set $P878, $P877["postcircumfix"] - unless_null $P878, vivify_313 + unless_null $P878, vivify_319 new $P878, "Undef" - vivify_313: + vivify_319: if $P878, if_876 .annotate 'line', 324 - .const 'Sub' $P886 = "61_1275511729.89077" + .const 'Sub' $P886 = "61_1275600017.58296" capture_lex $P886 $P886() goto if_876_end if_876: .annotate 'line', 321 find_lex $P879, "$/" - unless_null $P879, vivify_330 + unless_null $P879, vivify_336 $P879 = root_new ['parrot';'Hash'] - vivify_330: + vivify_336: set $P880, $P879["postcircumfix"] - unless_null $P880, vivify_331 + unless_null $P880, vivify_337 new $P880, "Undef" - vivify_331: + vivify_337: $P881 = $P880."ast"() store_lex "$past", $P881 .annotate 'line', 322 @@ -19858,7 +20230,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "_block885" :anon :subid("61_1275511729.89077") :outer("60_1275511729.89077") +.sub "_block885" :anon :subid("61_1275600017.58296") :outer("60_1275600017.58296") .annotate 'line', 325 $P887 = root_new ['parrot';'ResizablePMCArray'] .lex "@name", $P887 @@ -19879,13 +20251,13 @@ NQP::Compiler - NQP compiler unless $P898, if_897_end .annotate 'line', 328 find_lex $P900, "@name" - unless_null $P900, vivify_314 + unless_null $P900, vivify_320 $P900 = root_new ['parrot';'ResizablePMCArray'] - vivify_314: + vivify_320: set $P901, $P900[0] - unless_null $P901, vivify_315 + unless_null $P901, vivify_321 new $P901, "Undef" - vivify_315: + vivify_321: set $S902, $P901 iseq $I903, $S902, "GLOBAL" unless $I903, if_899_end @@ -19902,13 +20274,13 @@ NQP::Compiler - NQP compiler .annotate 'line', 331 find_lex $P908, "$past" find_lex $P909, "$/" - unless_null $P909, vivify_316 + unless_null $P909, vivify_322 $P909 = root_new ['parrot';'Hash'] - vivify_316: + vivify_322: set $P910, $P909["sigil"] - unless_null $P910, vivify_317 + unless_null $P910, vivify_323 new $P910, "Undef" - vivify_317: + vivify_323: $P911 = "vivitype"($P910) $P908."viviself"($P911) .annotate 'line', 332 @@ -19917,33 +20289,33 @@ NQP::Compiler - NQP compiler if_897_end: .annotate 'line', 334 find_lex $P915, "$/" - unless_null $P915, vivify_318 + unless_null $P915, vivify_324 $P915 = root_new ['parrot';'Hash'] - vivify_318: + vivify_324: set $P916, $P915["twigil"] - unless_null $P916, vivify_319 + unless_null $P916, vivify_325 $P916 = root_new ['parrot';'ResizablePMCArray'] - vivify_319: + vivify_325: set $P917, $P916[0] - unless_null $P917, vivify_320 + unless_null $P917, vivify_326 new $P917, "Undef" - vivify_320: + vivify_326: set $S918, $P917 iseq $I919, $S918, "*" if $I919, if_914 .annotate 'line', 347 find_lex $P941, "$/" - unless_null $P941, vivify_321 + unless_null $P941, vivify_327 $P941 = root_new ['parrot';'Hash'] - vivify_321: + vivify_327: set $P942, $P941["twigil"] - unless_null $P942, vivify_322 + unless_null $P942, vivify_328 $P942 = root_new ['parrot';'ResizablePMCArray'] - vivify_322: + vivify_328: set $P943, $P942[0] - unless_null $P943, vivify_323 + unless_null $P943, vivify_329 new $P943, "Undef" - vivify_323: + vivify_329: set $S944, $P943 iseq $I945, $S944, "!" if $I945, if_940 @@ -19962,13 +20334,13 @@ NQP::Compiler - NQP compiler .annotate 'line', 350 find_lex $P950, "$past" find_lex $P951, "$/" - unless_null $P951, vivify_324 + unless_null $P951, vivify_330 $P951 = root_new ['parrot';'Hash'] - vivify_324: + vivify_330: set $P952, $P951["sigil"] - unless_null $P952, vivify_325 + unless_null $P952, vivify_331 new $P952, "Undef" - vivify_325: + vivify_331: $P953 = "vivitype"($P952) $P954 = $P950."viviself"($P953) .annotate 'line', 347 @@ -19987,24 +20359,24 @@ NQP::Compiler - NQP compiler get_hll_global $P922, ["PAST"], "Var" .annotate 'line', 339 find_lex $P923, "$/" - unless_null $P923, vivify_326 + unless_null $P923, vivify_332 $P923 = root_new ['parrot';'Hash'] - vivify_326: + vivify_332: set $P924, $P923["sigil"] - unless_null $P924, vivify_327 + unless_null $P924, vivify_333 new $P924, "Undef" - vivify_327: + vivify_333: set $S925, $P924 new $P926, 'String' set $P926, $S925 find_lex $P927, "$/" - unless_null $P927, vivify_328 + unless_null $P927, vivify_334 $P927 = root_new ['parrot';'Hash'] - vivify_328: + vivify_334: set $P928, $P927["desigilname"] - unless_null $P928, vivify_329 + unless_null $P928, vivify_335 new $P928, "Undef" - vivify_329: + vivify_335: concat $P929, $P926, $P928 .annotate 'line', 341 get_hll_global $P930, ["PAST"], "Op" @@ -20027,7 +20399,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "package_declarator:sym" :subid("62_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "package_declarator:sym" :subid("62_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_962 .annotate 'line', 356 new $P961, 'ExceptionHandler' @@ -20038,13 +20410,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_962 find_lex $P963, "$/" find_lex $P964, "$/" - unless_null $P964, vivify_332 + unless_null $P964, vivify_338 $P964 = root_new ['parrot';'Hash'] - vivify_332: + vivify_338: set $P965, $P964["package_def"] - unless_null $P965, vivify_333 + unless_null $P965, vivify_339 new $P965, "Undef" - vivify_333: + vivify_339: $P966 = $P965."ast"() $P967 = $P963."!make"($P966) .return ($P967) @@ -20057,7 +20429,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "package_declarator:sym" :subid("63_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "package_declarator:sym" :subid("63_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_972 .annotate 'line', 357 new $P971, 'ExceptionHandler' @@ -20077,13 +20449,13 @@ NQP::Compiler - NQP compiler .lex "$parent", $P975 .annotate 'line', 358 find_lex $P976, "$/" - unless_null $P976, vivify_334 + unless_null $P976, vivify_340 $P976 = root_new ['parrot';'Hash'] - vivify_334: + vivify_340: set $P977, $P976["package_def"] - unless_null $P977, vivify_335 + unless_null $P977, vivify_341 new $P977, "Undef" - vivify_335: + vivify_341: $P978 = $P977."ast"() store_lex "$past", $P978 .annotate 'line', 360 @@ -20093,38 +20465,38 @@ NQP::Compiler - NQP compiler $P981 = $P980."new"(" %r = get_root_global [\"parrot\"], \"P6metaclass\"" :named("inline")) .annotate 'line', 364 find_lex $P982, "$/" - unless_null $P982, vivify_336 + unless_null $P982, vivify_342 $P982 = root_new ['parrot';'Hash'] - vivify_336: + vivify_342: set $P983, $P982["package_def"] - unless_null $P983, vivify_337 + unless_null $P983, vivify_343 $P983 = root_new ['parrot';'Hash'] - vivify_337: + vivify_343: set $P984, $P983["name"] - unless_null $P984, vivify_338 + unless_null $P984, vivify_344 new $P984, "Undef" - vivify_338: + vivify_344: set $S985, $P984 $P986 = $P979."new"($P981, $S985, "new_class" :named("name"), "callmethod" :named("pasttype")) .annotate 'line', 360 store_lex "$classinit", $P986 .annotate 'line', 368 find_lex $P989, "$/" - unless_null $P989, vivify_339 + unless_null $P989, vivify_345 $P989 = root_new ['parrot';'Hash'] - vivify_339: + vivify_345: set $P990, $P989["package_def"] - unless_null $P990, vivify_340 + unless_null $P990, vivify_346 $P990 = root_new ['parrot';'Hash'] - vivify_340: + vivify_346: set $P991, $P990["parent"] - unless_null $P991, vivify_341 + unless_null $P991, vivify_347 $P991 = root_new ['parrot';'ResizablePMCArray'] - vivify_341: + vivify_347: set $P992, $P991[0] - unless_null $P992, vivify_342 + unless_null $P992, vivify_348 new $P992, "Undef" - vivify_342: + vivify_348: set $S993, $P992 unless $S993, unless_988 new $P987, 'String' @@ -20133,13 +20505,13 @@ NQP::Compiler - NQP compiler unless_988: .annotate 'line', 369 find_lex $P996, "$/" - unless_null $P996, vivify_343 + unless_null $P996, vivify_349 $P996 = root_new ['parrot';'Hash'] - vivify_343: + vivify_349: set $P997, $P996["sym"] - unless_null $P997, vivify_344 + unless_null $P997, vivify_350 new $P997, "Undef" - vivify_344: + vivify_350: set $S998, $P997 iseq $I999, $S998, "grammar" if $I999, if_995 @@ -20167,35 +20539,35 @@ NQP::Compiler - NQP compiler if_1002_end: .annotate 'line', 373 find_lex $P1009, "$past" - unless_null $P1009, vivify_345 + unless_null $P1009, vivify_351 $P1009 = root_new ['parrot';'Hash'] - vivify_345: + vivify_351: set $P1010, $P1009["attributes"] - unless_null $P1010, vivify_346 + unless_null $P1010, vivify_352 new $P1010, "Undef" - vivify_346: + vivify_352: unless $P1010, if_1008_end .annotate 'line', 374 find_lex $P1011, "$classinit" find_lex $P1012, "$past" - unless_null $P1012, vivify_347 + unless_null $P1012, vivify_353 $P1012 = root_new ['parrot';'Hash'] - vivify_347: + vivify_353: set $P1013, $P1012["attributes"] - unless_null $P1013, vivify_348 + unless_null $P1013, vivify_354 new $P1013, "Undef" - vivify_348: + vivify_354: $P1011."push"($P1013) if_1008_end: .annotate 'line', 376 get_global $P1014, "@BLOCK" - unless_null $P1014, vivify_349 + unless_null $P1014, vivify_355 $P1014 = root_new ['parrot';'ResizablePMCArray'] - vivify_349: + vivify_355: set $P1015, $P1014[0] - unless_null $P1015, vivify_350 + unless_null $P1015, vivify_356 new $P1015, "Undef" - vivify_350: + vivify_356: $P1016 = $P1015."loadinit"() find_lex $P1017, "$classinit" $P1016."push"($P1017) @@ -20214,7 +20586,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "package_def" :subid("64_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "package_def" :subid("64_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_1025 .annotate 'line', 380 new $P1024, 'ExceptionHandler' @@ -20227,34 +20599,34 @@ NQP::Compiler - NQP compiler new $P1026, "Undef" .lex "$past", $P1026 find_lex $P1029, "$/" - unless_null $P1029, vivify_351 + unless_null $P1029, vivify_357 $P1029 = root_new ['parrot';'Hash'] - vivify_351: + vivify_357: set $P1030, $P1029["block"] - unless_null $P1030, vivify_352 + unless_null $P1030, vivify_358 new $P1030, "Undef" - vivify_352: + vivify_358: if $P1030, if_1028 find_lex $P1034, "$/" - unless_null $P1034, vivify_353 + unless_null $P1034, vivify_359 $P1034 = root_new ['parrot';'Hash'] - vivify_353: + vivify_359: set $P1035, $P1034["comp_unit"] - unless_null $P1035, vivify_354 + unless_null $P1035, vivify_360 new $P1035, "Undef" - vivify_354: + vivify_360: $P1036 = $P1035."ast"() set $P1027, $P1036 goto if_1028_end if_1028: find_lex $P1031, "$/" - unless_null $P1031, vivify_355 + unless_null $P1031, vivify_361 $P1031 = root_new ['parrot';'Hash'] - vivify_355: + vivify_361: set $P1032, $P1031["block"] - unless_null $P1032, vivify_356 + unless_null $P1032, vivify_362 new $P1032, "Undef" - vivify_356: + vivify_362: $P1033 = $P1032."ast"() set $P1027, $P1033 if_1028_end: @@ -20262,17 +20634,17 @@ NQP::Compiler - NQP compiler .annotate 'line', 382 find_lex $P1037, "$past" find_lex $P1038, "$/" - unless_null $P1038, vivify_357 + unless_null $P1038, vivify_363 $P1038 = root_new ['parrot';'Hash'] - vivify_357: + vivify_363: set $P1039, $P1038["name"] - unless_null $P1039, vivify_358 + unless_null $P1039, vivify_364 $P1039 = root_new ['parrot';'Hash'] - vivify_358: + vivify_364: set $P1040, $P1039["identifier"] - unless_null $P1040, vivify_359 + unless_null $P1040, vivify_365 new $P1040, "Undef" - vivify_359: + vivify_365: $P1037."namespace"($P1040) .annotate 'line', 383 find_lex $P1041, "$past" @@ -20292,7 +20664,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "scope_declarator:sym" :subid("65_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "scope_declarator:sym" :subid("65_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_1049 .annotate 'line', 387 new $P1048, 'ExceptionHandler' @@ -20303,13 +20675,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_1049 find_lex $P1050, "$/" find_lex $P1051, "$/" - unless_null $P1051, vivify_360 + unless_null $P1051, vivify_366 $P1051 = root_new ['parrot';'Hash'] - vivify_360: + vivify_366: set $P1052, $P1051["scoped"] - unless_null $P1052, vivify_361 + unless_null $P1052, vivify_367 new $P1052, "Undef" - vivify_361: + vivify_367: $P1053 = $P1052."ast"() $P1054 = $P1050."!make"($P1053) .return ($P1054) @@ -20322,7 +20694,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "scope_declarator:sym" :subid("66_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "scope_declarator:sym" :subid("66_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_1059 .annotate 'line', 388 new $P1058, 'ExceptionHandler' @@ -20333,13 +20705,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_1059 find_lex $P1060, "$/" find_lex $P1061, "$/" - unless_null $P1061, vivify_362 + unless_null $P1061, vivify_368 $P1061 = root_new ['parrot';'Hash'] - vivify_362: + vivify_368: set $P1062, $P1061["scoped"] - unless_null $P1062, vivify_363 + unless_null $P1062, vivify_369 new $P1062, "Undef" - vivify_363: + vivify_369: $P1063 = $P1062."ast"() $P1064 = $P1060."!make"($P1063) .return ($P1064) @@ -20352,7 +20724,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "scope_declarator:sym" :subid("67_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "scope_declarator:sym" :subid("67_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_1069 .annotate 'line', 389 new $P1068, 'ExceptionHandler' @@ -20363,13 +20735,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_1069 find_lex $P1070, "$/" find_lex $P1071, "$/" - unless_null $P1071, vivify_364 + unless_null $P1071, vivify_370 $P1071 = root_new ['parrot';'Hash'] - vivify_364: + vivify_370: set $P1072, $P1071["scoped"] - unless_null $P1072, vivify_365 + unless_null $P1072, vivify_371 new $P1072, "Undef" - vivify_365: + vivify_371: $P1073 = $P1072."ast"() $P1074 = $P1070."!make"($P1073) .return ($P1074) @@ -20382,7 +20754,7 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "scoped" :subid("68_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "scoped" :subid("68_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_1079 .annotate 'line', 391 new $P1078, 'ExceptionHandler' @@ -20393,572 +20765,511 @@ NQP::Compiler - NQP compiler .lex "$/", param_1079 .annotate 'line', 392 find_lex $P1080, "$/" - find_lex $P1081, "$/" - unless_null $P1081, vivify_366 - $P1081 = root_new ['parrot';'Hash'] - vivify_366: - set $P1082, $P1081["declarator"] - unless_null $P1082, vivify_367 - new $P1082, "Undef" - vivify_367: - $P1083 = $P1082."ast"() - $P1084 = $P1080."!make"($P1083) +.annotate 'line', 393 + find_lex $P1083, "$/" + unless_null $P1083, vivify_372 + $P1083 = root_new ['parrot';'Hash'] + vivify_372: + set $P1084, $P1083["declarator"] + unless_null $P1084, vivify_373 + new $P1084, "Undef" + vivify_373: + if $P1084, if_1082 +.annotate 'line', 394 + find_lex $P1088, "$/" + unless_null $P1088, vivify_374 + $P1088 = root_new ['parrot';'Hash'] + vivify_374: + set $P1089, $P1088["multi_declarator"] + unless_null $P1089, vivify_375 + new $P1089, "Undef" + vivify_375: + $P1090 = $P1089."ast"() + set $P1081, $P1090 +.annotate 'line', 393 + goto if_1082_end + if_1082: + find_lex $P1085, "$/" + unless_null $P1085, vivify_376 + $P1085 = root_new ['parrot';'Hash'] + vivify_376: + set $P1086, $P1085["declarator"] + unless_null $P1086, vivify_377 + new $P1086, "Undef" + vivify_377: + $P1087 = $P1086."ast"() + set $P1081, $P1087 + if_1082_end: + $P1091 = $P1080."!make"($P1081) .annotate 'line', 391 - .return ($P1084) + .return ($P1091) control_1077: .local pmc exception .get_results (exception) - getattribute $P1085, exception, "payload" - .return ($P1085) + getattribute $P1092, exception, "payload" + .return ($P1092) .end .namespace ["NQP";"Actions"] -.sub "declarator" :subid("69_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1089 -.annotate 'line', 395 - new $P1088, 'ExceptionHandler' - set_addr $P1088, control_1087 - $P1088."handle_types"(57) - push_eh $P1088 - .lex "self", self - .lex "$/", param_1089 -.annotate 'line', 396 - find_lex $P1090, "$/" +.sub "declarator" :subid("69_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1096 .annotate 'line', 397 - find_lex $P1093, "$/" - unless_null $P1093, vivify_368 - $P1093 = root_new ['parrot';'Hash'] - vivify_368: - set $P1094, $P1093["routine_declarator"] - unless_null $P1094, vivify_369 - new $P1094, "Undef" - vivify_369: - if $P1094, if_1092 + new $P1095, 'ExceptionHandler' + set_addr $P1095, control_1094 + $P1095."handle_types"(57) + push_eh $P1095 + .lex "self", self + .lex "$/", param_1096 .annotate 'line', 398 - find_lex $P1098, "$/" - unless_null $P1098, vivify_370 - $P1098 = root_new ['parrot';'Hash'] - vivify_370: - set $P1099, $P1098["variable_declarator"] - unless_null $P1099, vivify_371 - new $P1099, "Undef" - vivify_371: - $P1100 = $P1099."ast"() - set $P1091, $P1100 + find_lex $P1097, "$/" +.annotate 'line', 399 + find_lex $P1100, "$/" + unless_null $P1100, vivify_378 + $P1100 = root_new ['parrot';'Hash'] + vivify_378: + set $P1101, $P1100["routine_declarator"] + unless_null $P1101, vivify_379 + new $P1101, "Undef" + vivify_379: + if $P1101, if_1099 +.annotate 'line', 400 + find_lex $P1105, "$/" + unless_null $P1105, vivify_380 + $P1105 = root_new ['parrot';'Hash'] + vivify_380: + set $P1106, $P1105["variable_declarator"] + unless_null $P1106, vivify_381 + new $P1106, "Undef" + vivify_381: + $P1107 = $P1106."ast"() + set $P1098, $P1107 +.annotate 'line', 399 + goto if_1099_end + if_1099: + find_lex $P1102, "$/" + unless_null $P1102, vivify_382 + $P1102 = root_new ['parrot';'Hash'] + vivify_382: + set $P1103, $P1102["routine_declarator"] + unless_null $P1103, vivify_383 + new $P1103, "Undef" + vivify_383: + $P1104 = $P1103."ast"() + set $P1098, $P1104 + if_1099_end: + $P1108 = $P1097."!make"($P1098) .annotate 'line', 397 - goto if_1092_end - if_1092: - find_lex $P1095, "$/" - unless_null $P1095, vivify_372 - $P1095 = root_new ['parrot';'Hash'] - vivify_372: - set $P1096, $P1095["routine_declarator"] - unless_null $P1096, vivify_373 - new $P1096, "Undef" - vivify_373: - $P1097 = $P1096."ast"() - set $P1091, $P1097 - if_1092_end: - $P1101 = $P1090."!make"($P1091) -.annotate 'line', 395 - .return ($P1101) - control_1087: + .return ($P1108) + control_1094: .local pmc exception .get_results (exception) - getattribute $P1102, exception, "payload" - .return ($P1102) + getattribute $P1109, exception, "payload" + .return ($P1109) .end .namespace ["NQP";"Actions"] -.sub "variable_declarator" :subid("70_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1106 -.annotate 'line', 401 - .const 'Sub' $P1146 = "71_1275511729.89077" - capture_lex $P1146 - new $P1105, 'ExceptionHandler' - set_addr $P1105, control_1104 - $P1105."handle_types"(57) - push_eh $P1105 - .lex "self", self - .lex "$/", param_1106 -.annotate 'line', 402 - new $P1107, "Undef" - .lex "$past", $P1107 -.annotate 'line', 403 - new $P1108, "Undef" - .lex "$sigil", $P1108 -.annotate 'line', 404 - new $P1109, "Undef" - .lex "$name", $P1109 -.annotate 'line', 405 - new $P1110, "Undef" - .lex "$BLOCK", $P1110 -.annotate 'line', 402 - find_lex $P1111, "$/" - unless_null $P1111, vivify_374 - $P1111 = root_new ['parrot';'Hash'] - vivify_374: - set $P1112, $P1111["variable"] - unless_null $P1112, vivify_375 - new $P1112, "Undef" - vivify_375: - $P1113 = $P1112."ast"() - store_lex "$past", $P1113 +.sub "multi_declarator:sym" :subid("70_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1113 .annotate 'line', 403 + new $P1112, 'ExceptionHandler' + set_addr $P1112, control_1111 + $P1112."handle_types"(57) + push_eh $P1112 + .lex "self", self + .lex "$/", param_1113 find_lex $P1114, "$/" - unless_null $P1114, vivify_376 - $P1114 = root_new ['parrot';'Hash'] - vivify_376: - set $P1115, $P1114["variable"] - unless_null $P1115, vivify_377 - $P1115 = root_new ['parrot';'Hash'] - vivify_377: - set $P1116, $P1115["sigil"] - unless_null $P1116, vivify_378 - new $P1116, "Undef" - vivify_378: - store_lex "$sigil", $P1116 -.annotate 'line', 404 - find_lex $P1117, "$past" - $P1118 = $P1117."name"() - store_lex "$name", $P1118 -.annotate 'line', 405 - get_global $P1119, "@BLOCK" - unless_null $P1119, vivify_379 - $P1119 = root_new ['parrot';'ResizablePMCArray'] - vivify_379: - set $P1120, $P1119[0] - unless_null $P1120, vivify_380 - new $P1120, "Undef" - vivify_380: - store_lex "$BLOCK", $P1120 -.annotate 'line', 406 - find_lex $P1122, "$BLOCK" - find_lex $P1123, "$name" - $P1124 = $P1122."symbol"($P1123) - unless $P1124, if_1121_end -.annotate 'line', 407 - find_lex $P1125, "$/" - $P1126 = $P1125."CURSOR"() - find_lex $P1127, "$name" - $P1126."panic"("Redeclaration of symbol ", $P1127) - if_1121_end: -.annotate 'line', 409 - find_dynamic_lex $P1129, "$*SCOPE" - unless_null $P1129, vivify_381 - get_hll_global $P1129, "$SCOPE" - unless_null $P1129, vivify_382 - die "Contextual $*SCOPE not found" - vivify_382: - vivify_381: - set $S1130, $P1129 - iseq $I1131, $S1130, "has" - if $I1131, if_1128 -.annotate 'line', 418 - .const 'Sub' $P1146 = "71_1275511729.89077" - capture_lex $P1146 - $P1146() - goto if_1128_end - if_1128: -.annotate 'line', 410 - find_lex $P1132, "$BLOCK" - find_lex $P1133, "$name" - $P1132."symbol"($P1133, "attribute" :named("scope")) -.annotate 'line', 411 - find_lex $P1135, "$BLOCK" - unless_null $P1135, vivify_387 - $P1135 = root_new ['parrot';'Hash'] + find_lex $P1117, "$/" + unless_null $P1117, vivify_384 + $P1117 = root_new ['parrot';'Hash'] + vivify_384: + set $P1118, $P1117["declarator"] + unless_null $P1118, vivify_385 + new $P1118, "Undef" + vivify_385: + if $P1118, if_1116 + find_lex $P1122, "$/" + unless_null $P1122, vivify_386 + $P1122 = root_new ['parrot';'Hash'] + vivify_386: + set $P1123, $P1122["routine_def"] + unless_null $P1123, vivify_387 + new $P1123, "Undef" vivify_387: - set $P1136, $P1135["attributes"] - unless_null $P1136, vivify_388 - new $P1136, "Undef" + $P1124 = $P1123."ast"() + set $P1115, $P1124 + goto if_1116_end + if_1116: + find_lex $P1119, "$/" + unless_null $P1119, vivify_388 + $P1119 = root_new ['parrot';'Hash'] vivify_388: - if $P1136, unless_1134_end -.annotate 'line', 413 - get_hll_global $P1137, ["PAST"], "Op" - $P1138 = $P1137."new"("list" :named("pasttype"), "attr" :named("named")) - find_lex $P1139, "$BLOCK" - unless_null $P1139, vivify_389 - $P1139 = root_new ['parrot';'Hash'] - store_lex "$BLOCK", $P1139 + set $P1120, $P1119["declarator"] + unless_null $P1120, vivify_389 + new $P1120, "Undef" vivify_389: - set $P1139["attributes"], $P1138 - unless_1134_end: -.annotate 'line', 415 - find_lex $P1140, "$BLOCK" - unless_null $P1140, vivify_390 - $P1140 = root_new ['parrot';'Hash'] - vivify_390: - set $P1141, $P1140["attributes"] - unless_null $P1141, vivify_391 - new $P1141, "Undef" - vivify_391: - find_lex $P1142, "$name" - $P1141."push"($P1142) -.annotate 'line', 416 - get_hll_global $P1143, ["PAST"], "Stmts" - $P1144 = $P1143."new"() - store_lex "$past", $P1144 - if_1128_end: -.annotate 'line', 426 - find_lex $P1170, "$/" - find_lex $P1171, "$past" - $P1172 = $P1170."!make"($P1171) -.annotate 'line', 401 - .return ($P1172) - control_1104: + $P1121 = $P1120."ast"() + set $P1115, $P1121 + if_1116_end: + $P1125 = $P1114."!make"($P1115) + .return ($P1125) + control_1111: .local pmc exception .get_results (exception) - getattribute $P1173, exception, "payload" - .return ($P1173) -.end - - -.namespace ["NQP";"Actions"] -.sub "_block1145" :anon :subid("71_1275511729.89077") :outer("70_1275511729.89077") -.annotate 'line', 419 - new $P1147, "Undef" - .lex "$scope", $P1147 -.annotate 'line', 420 - new $P1148, "Undef" - .lex "$decl", $P1148 -.annotate 'line', 419 - find_dynamic_lex $P1151, "$*SCOPE" - unless_null $P1151, vivify_383 - get_hll_global $P1151, "$SCOPE" - unless_null $P1151, vivify_384 - die "Contextual $*SCOPE not found" - vivify_384: - vivify_383: - set $S1152, $P1151 - iseq $I1153, $S1152, "our" - if $I1153, if_1150 - new $P1155, "String" - assign $P1155, "lexical" - set $P1149, $P1155 - goto if_1150_end - if_1150: - new $P1154, "String" - assign $P1154, "package" - set $P1149, $P1154 - if_1150_end: - store_lex "$scope", $P1149 -.annotate 'line', 420 - get_hll_global $P1156, ["PAST"], "Var" - find_lex $P1157, "$name" - find_lex $P1158, "$scope" -.annotate 'line', 421 - find_lex $P1159, "$sigil" - $P1160 = "vivitype"($P1159) - find_lex $P1161, "$/" - $P1162 = $P1156."new"($P1157 :named("name"), $P1158 :named("scope"), 1 :named("isdecl"), 1 :named("lvalue"), $P1160 :named("viviself"), $P1161 :named("node")) -.annotate 'line', 420 - store_lex "$decl", $P1162 -.annotate 'line', 423 - find_lex $P1163, "$BLOCK" - find_lex $P1164, "$name" - find_lex $P1165, "$scope" - $P1163."symbol"($P1164, $P1165 :named("scope")) -.annotate 'line', 424 - find_lex $P1166, "$BLOCK" - unless_null $P1166, vivify_385 - $P1166 = root_new ['parrot';'ResizablePMCArray'] - vivify_385: - set $P1167, $P1166[0] - unless_null $P1167, vivify_386 - new $P1167, "Undef" - vivify_386: - find_lex $P1168, "$decl" - $P1169 = $P1167."push"($P1168) -.annotate 'line', 418 - .return ($P1169) + getattribute $P1126, exception, "payload" + .return ($P1126) .end .namespace ["NQP";"Actions"] -.sub "routine_declarator:sym" :subid("72_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1177 -.annotate 'line', 429 - new $P1176, 'ExceptionHandler' - set_addr $P1176, control_1175 - $P1176."handle_types"(57) - push_eh $P1176 +.sub "multi_declarator:sym" :subid("71_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1130 +.annotate 'line', 404 + new $P1129, 'ExceptionHandler' + set_addr $P1129, control_1128 + $P1129."handle_types"(57) + push_eh $P1129 .lex "self", self - .lex "$/", param_1177 - find_lex $P1178, "$/" - find_lex $P1179, "$/" - unless_null $P1179, vivify_392 - $P1179 = root_new ['parrot';'Hash'] - vivify_392: - set $P1180, $P1179["routine_def"] - unless_null $P1180, vivify_393 - new $P1180, "Undef" - vivify_393: - $P1181 = $P1180."ast"() - $P1182 = $P1178."!make"($P1181) - .return ($P1182) - control_1175: + .lex "$/", param_1130 + find_lex $P1131, "$/" + find_lex $P1132, "$/" + unless_null $P1132, vivify_390 + $P1132 = root_new ['parrot';'Hash'] + vivify_390: + set $P1133, $P1132["declarator"] + unless_null $P1133, vivify_391 + new $P1133, "Undef" + vivify_391: + $P1134 = $P1133."ast"() + $P1135 = $P1131."!make"($P1134) + .return ($P1135) + control_1128: .local pmc exception .get_results (exception) - getattribute $P1183, exception, "payload" - .return ($P1183) + getattribute $P1136, exception, "payload" + .return ($P1136) .end .namespace ["NQP";"Actions"] -.sub "routine_declarator:sym" :subid("73_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1187 -.annotate 'line', 430 - new $P1186, 'ExceptionHandler' - set_addr $P1186, control_1185 - $P1186."handle_types"(57) - push_eh $P1186 +.sub "variable_declarator" :subid("72_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1140 +.annotate 'line', 407 + .const 'Sub' $P1180 = "73_1275600017.58296" + capture_lex $P1180 + new $P1139, 'ExceptionHandler' + set_addr $P1139, control_1138 + $P1139."handle_types"(57) + push_eh $P1139 .lex "self", self - .lex "$/", param_1187 - find_lex $P1188, "$/" - find_lex $P1189, "$/" - unless_null $P1189, vivify_394 - $P1189 = root_new ['parrot';'Hash'] + .lex "$/", param_1140 +.annotate 'line', 408 + new $P1141, "Undef" + .lex "$past", $P1141 +.annotate 'line', 409 + new $P1142, "Undef" + .lex "$sigil", $P1142 +.annotate 'line', 410 + new $P1143, "Undef" + .lex "$name", $P1143 +.annotate 'line', 411 + new $P1144, "Undef" + .lex "$BLOCK", $P1144 +.annotate 'line', 408 + find_lex $P1145, "$/" + unless_null $P1145, vivify_392 + $P1145 = root_new ['parrot';'Hash'] + vivify_392: + set $P1146, $P1145["variable"] + unless_null $P1146, vivify_393 + new $P1146, "Undef" + vivify_393: + $P1147 = $P1146."ast"() + store_lex "$past", $P1147 +.annotate 'line', 409 + find_lex $P1148, "$/" + unless_null $P1148, vivify_394 + $P1148 = root_new ['parrot';'Hash'] vivify_394: - set $P1190, $P1189["method_def"] - unless_null $P1190, vivify_395 - new $P1190, "Undef" + set $P1149, $P1148["variable"] + unless_null $P1149, vivify_395 + $P1149 = root_new ['parrot';'Hash'] vivify_395: - $P1191 = $P1190."ast"() - $P1192 = $P1188."!make"($P1191) - .return ($P1192) - control_1185: - .local pmc exception - .get_results (exception) - getattribute $P1193, exception, "payload" - .return ($P1193) -.end - - -.namespace ["NQP";"Actions"] -.sub "routine_def" :subid("74_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1197 -.annotate 'line', 432 - .const 'Sub' $P1208 = "75_1275511729.89077" - capture_lex $P1208 - new $P1196, 'ExceptionHandler' - set_addr $P1196, control_1195 - $P1196."handle_types"(57) - push_eh $P1196 - .lex "self", self - .lex "$/", param_1197 -.annotate 'line', 433 - new $P1198, "Undef" - .lex "$past", $P1198 - find_lex $P1199, "$/" - unless_null $P1199, vivify_396 - $P1199 = root_new ['parrot';'Hash'] + set $P1150, $P1149["sigil"] + unless_null $P1150, vivify_396 + new $P1150, "Undef" vivify_396: - set $P1200, $P1199["blockoid"] - unless_null $P1200, vivify_397 - new $P1200, "Undef" + store_lex "$sigil", $P1150 +.annotate 'line', 410 + find_lex $P1151, "$past" + $P1152 = $P1151."name"() + store_lex "$name", $P1152 +.annotate 'line', 411 + get_global $P1153, "@BLOCK" + unless_null $P1153, vivify_397 + $P1153 = root_new ['parrot';'ResizablePMCArray'] vivify_397: - $P1201 = $P1200."ast"() - store_lex "$past", $P1201 -.annotate 'line', 434 - find_lex $P1202, "$past" - $P1202."blocktype"("declaration") -.annotate 'line', 435 - find_lex $P1203, "$past" - $P1203."control"("return_pir") -.annotate 'line', 436 - find_lex $P1205, "$/" - unless_null $P1205, vivify_398 - $P1205 = root_new ['parrot';'Hash'] + set $P1154, $P1153[0] + unless_null $P1154, vivify_398 + new $P1154, "Undef" vivify_398: - set $P1206, $P1205["deflongname"] - unless_null $P1206, vivify_399 - new $P1206, "Undef" + store_lex "$BLOCK", $P1154 +.annotate 'line', 412 + find_lex $P1156, "$BLOCK" + find_lex $P1157, "$name" + $P1158 = $P1156."symbol"($P1157) + unless $P1158, if_1155_end +.annotate 'line', 413 + find_lex $P1159, "$/" + $P1160 = $P1159."CURSOR"() + find_lex $P1161, "$name" + $P1160."panic"("Redeclaration of symbol ", $P1161) + if_1155_end: +.annotate 'line', 415 + find_dynamic_lex $P1163, "$*SCOPE" + unless_null $P1163, vivify_399 + get_hll_global $P1163, "$SCOPE" + unless_null $P1163, vivify_400 + die "Contextual $*SCOPE not found" + vivify_400: vivify_399: - unless $P1206, if_1204_end - .const 'Sub' $P1208 = "75_1275511729.89077" - capture_lex $P1208 - $P1208() - if_1204_end: -.annotate 'line', 446 - find_lex $P1240, "$/" - find_lex $P1241, "$past" - $P1242 = $P1240."!make"($P1241) -.annotate 'line', 432 - .return ($P1242) - control_1195: - .local pmc exception + set $S1164, $P1163 + iseq $I1165, $S1164, "has" + if $I1165, if_1162 +.annotate 'line', 424 + .const 'Sub' $P1180 = "73_1275600017.58296" + capture_lex $P1180 + $P1180() + goto if_1162_end + if_1162: +.annotate 'line', 416 + find_lex $P1166, "$BLOCK" + find_lex $P1167, "$name" + $P1166."symbol"($P1167, "attribute" :named("scope")) +.annotate 'line', 417 + find_lex $P1169, "$BLOCK" + unless_null $P1169, vivify_405 + $P1169 = root_new ['parrot';'Hash'] + vivify_405: + set $P1170, $P1169["attributes"] + unless_null $P1170, vivify_406 + new $P1170, "Undef" + vivify_406: + if $P1170, unless_1168_end +.annotate 'line', 419 + get_hll_global $P1171, ["PAST"], "Op" + $P1172 = $P1171."new"("list" :named("pasttype"), "attr" :named("named")) + find_lex $P1173, "$BLOCK" + unless_null $P1173, vivify_407 + $P1173 = root_new ['parrot';'Hash'] + store_lex "$BLOCK", $P1173 + vivify_407: + set $P1173["attributes"], $P1172 + unless_1168_end: +.annotate 'line', 421 + find_lex $P1174, "$BLOCK" + unless_null $P1174, vivify_408 + $P1174 = root_new ['parrot';'Hash'] + vivify_408: + set $P1175, $P1174["attributes"] + unless_null $P1175, vivify_409 + new $P1175, "Undef" + vivify_409: + find_lex $P1176, "$name" + $P1175."push"($P1176) +.annotate 'line', 422 + get_hll_global $P1177, ["PAST"], "Stmts" + $P1178 = $P1177."new"() + store_lex "$past", $P1178 + if_1162_end: +.annotate 'line', 432 + find_lex $P1204, "$/" + find_lex $P1205, "$past" + $P1206 = $P1204."!make"($P1205) +.annotate 'line', 407 + .return ($P1206) + control_1138: + .local pmc exception .get_results (exception) - getattribute $P1243, exception, "payload" - .return ($P1243) + getattribute $P1207, exception, "payload" + .return ($P1207) .end .namespace ["NQP";"Actions"] -.sub "_block1207" :anon :subid("75_1275511729.89077") :outer("74_1275511729.89077") -.annotate 'line', 437 - new $P1209, "Undef" - .lex "$name", $P1209 - find_lex $P1210, "$/" - unless_null $P1210, vivify_400 - $P1210 = root_new ['parrot';'Hash'] - vivify_400: - set $P1211, $P1210["sigil"] - unless_null $P1211, vivify_401 - $P1211 = root_new ['parrot';'ResizablePMCArray'] - vivify_401: - set $P1212, $P1211[0] - unless_null $P1212, vivify_402 - new $P1212, "Undef" +.sub "_block1179" :anon :subid("73_1275600017.58296") :outer("72_1275600017.58296") +.annotate 'line', 425 + new $P1181, "Undef" + .lex "$scope", $P1181 +.annotate 'line', 426 + new $P1182, "Undef" + .lex "$decl", $P1182 +.annotate 'line', 425 + find_dynamic_lex $P1185, "$*SCOPE" + unless_null $P1185, vivify_401 + get_hll_global $P1185, "$SCOPE" + unless_null $P1185, vivify_402 + die "Contextual $*SCOPE not found" vivify_402: - set $S1213, $P1212 - new $P1214, 'String' - set $P1214, $S1213 - find_lex $P1215, "$/" - unless_null $P1215, vivify_403 - $P1215 = root_new ['parrot';'Hash'] + vivify_401: + set $S1186, $P1185 + iseq $I1187, $S1186, "our" + if $I1187, if_1184 + new $P1189, "String" + assign $P1189, "lexical" + set $P1183, $P1189 + goto if_1184_end + if_1184: + new $P1188, "String" + assign $P1188, "package" + set $P1183, $P1188 + if_1184_end: + store_lex "$scope", $P1183 +.annotate 'line', 426 + get_hll_global $P1190, ["PAST"], "Var" + find_lex $P1191, "$name" + find_lex $P1192, "$scope" +.annotate 'line', 427 + find_lex $P1193, "$sigil" + $P1194 = "vivitype"($P1193) + find_lex $P1195, "$/" + $P1196 = $P1190."new"($P1191 :named("name"), $P1192 :named("scope"), 1 :named("isdecl"), 1 :named("lvalue"), $P1194 :named("viviself"), $P1195 :named("node")) +.annotate 'line', 426 + store_lex "$decl", $P1196 +.annotate 'line', 429 + find_lex $P1197, "$BLOCK" + find_lex $P1198, "$name" + find_lex $P1199, "$scope" + $P1197."symbol"($P1198, $P1199 :named("scope")) +.annotate 'line', 430 + find_lex $P1200, "$BLOCK" + unless_null $P1200, vivify_403 + $P1200 = root_new ['parrot';'ResizablePMCArray'] vivify_403: - set $P1216, $P1215["deflongname"] - unless_null $P1216, vivify_404 - $P1216 = root_new ['parrot';'ResizablePMCArray'] + set $P1201, $P1200[0] + unless_null $P1201, vivify_404 + new $P1201, "Undef" vivify_404: - set $P1217, $P1216[0] - unless_null $P1217, vivify_405 - new $P1217, "Undef" - vivify_405: - $S1218 = $P1217."ast"() - concat $P1219, $P1214, $S1218 - store_lex "$name", $P1219 -.annotate 'line', 438 - find_lex $P1220, "$past" - find_lex $P1221, "$name" - $P1220."name"($P1221) -.annotate 'line', 439 - find_dynamic_lex $P1224, "$*SCOPE" - unless_null $P1224, vivify_406 - get_hll_global $P1224, "$SCOPE" - unless_null $P1224, vivify_407 - die "Contextual $*SCOPE not found" - vivify_407: - vivify_406: - set $S1225, $P1224 - isne $I1226, $S1225, "our" - if $I1226, if_1223 - new $P1222, 'Integer' - set $P1222, $I1226 - goto if_1223_end - if_1223: -.annotate 'line', 440 - get_global $P1227, "@BLOCK" - unless_null $P1227, vivify_408 - $P1227 = root_new ['parrot';'ResizablePMCArray'] - vivify_408: - set $P1228, $P1227[0] - unless_null $P1228, vivify_409 - $P1228 = root_new ['parrot';'ResizablePMCArray'] - vivify_409: - set $P1229, $P1228[0] - unless_null $P1229, vivify_410 - new $P1229, "Undef" + find_lex $P1202, "$decl" + $P1203 = $P1201."push"($P1202) +.annotate 'line', 424 + .return ($P1203) +.end + + +.namespace ["NQP";"Actions"] +.sub "routine_declarator:sym" :subid("74_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1211 +.annotate 'line', 435 + new $P1210, 'ExceptionHandler' + set_addr $P1210, control_1209 + $P1210."handle_types"(57) + push_eh $P1210 + .lex "self", self + .lex "$/", param_1211 + find_lex $P1212, "$/" + find_lex $P1213, "$/" + unless_null $P1213, vivify_410 + $P1213 = root_new ['parrot';'Hash'] vivify_410: - get_hll_global $P1230, ["PAST"], "Var" - find_lex $P1231, "$name" - find_lex $P1232, "$past" - $P1233 = $P1230."new"($P1231 :named("name"), 1 :named("isdecl"), $P1232 :named("viviself"), "lexical" :named("scope")) - $P1229."push"($P1233) -.annotate 'line', 442 - get_global $P1234, "@BLOCK" - unless_null $P1234, vivify_411 - $P1234 = root_new ['parrot';'ResizablePMCArray'] + set $P1214, $P1213["routine_def"] + unless_null $P1214, vivify_411 + new $P1214, "Undef" vivify_411: - set $P1235, $P1234[0] - unless_null $P1235, vivify_412 - new $P1235, "Undef" - vivify_412: - find_lex $P1236, "$name" - $P1235."symbol"($P1236, "lexical" :named("scope")) -.annotate 'line', 443 - get_hll_global $P1237, ["PAST"], "Var" - find_lex $P1238, "$name" - $P1239 = $P1237."new"($P1238 :named("name")) - store_lex "$past", $P1239 -.annotate 'line', 439 - set $P1222, $P1239 - if_1223_end: -.annotate 'line', 436 - .return ($P1222) + $P1215 = $P1214."ast"() + $P1216 = $P1212."!make"($P1215) + .return ($P1216) + control_1209: + .local pmc exception + .get_results (exception) + getattribute $P1217, exception, "payload" + .return ($P1217) .end .namespace ["NQP";"Actions"] -.sub "method_def" :subid("76_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1247 -.annotate 'line', 450 - .const 'Sub' $P1263 = "77_1275511729.89077" - capture_lex $P1263 - new $P1246, 'ExceptionHandler' - set_addr $P1246, control_1245 - $P1246."handle_types"(57) - push_eh $P1246 +.sub "routine_declarator:sym" :subid("75_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1221 +.annotate 'line', 436 + new $P1220, 'ExceptionHandler' + set_addr $P1220, control_1219 + $P1220."handle_types"(57) + push_eh $P1220 .lex "self", self - .lex "$/", param_1247 -.annotate 'line', 451 - new $P1248, "Undef" - .lex "$past", $P1248 - find_lex $P1249, "$/" - unless_null $P1249, vivify_413 - $P1249 = root_new ['parrot';'Hash'] + .lex "$/", param_1221 + find_lex $P1222, "$/" + find_lex $P1223, "$/" + unless_null $P1223, vivify_412 + $P1223 = root_new ['parrot';'Hash'] + vivify_412: + set $P1224, $P1223["method_def"] + unless_null $P1224, vivify_413 + new $P1224, "Undef" vivify_413: - set $P1250, $P1249["blockoid"] - unless_null $P1250, vivify_414 - new $P1250, "Undef" + $P1225 = $P1224."ast"() + $P1226 = $P1222."!make"($P1225) + .return ($P1226) + control_1219: + .local pmc exception + .get_results (exception) + getattribute $P1227, exception, "payload" + .return ($P1227) +.end + + +.namespace ["NQP";"Actions"] +.sub "routine_def" :subid("76_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1231 +.annotate 'line', 438 + .const 'Sub' $P1242 = "77_1275600017.58296" + capture_lex $P1242 + new $P1230, 'ExceptionHandler' + set_addr $P1230, control_1229 + $P1230."handle_types"(57) + push_eh $P1230 + .lex "self", self + .lex "$/", param_1231 +.annotate 'line', 439 + new $P1232, "Undef" + .lex "$past", $P1232 + find_lex $P1233, "$/" + unless_null $P1233, vivify_414 + $P1233 = root_new ['parrot';'Hash'] vivify_414: - $P1251 = $P1250."ast"() - store_lex "$past", $P1251 -.annotate 'line', 452 - find_lex $P1252, "$past" - $P1252."blocktype"("method") -.annotate 'line', 453 - find_lex $P1253, "$past" - $P1253."control"("return_pir") -.annotate 'line', 454 - find_lex $P1254, "$past" - unless_null $P1254, vivify_415 - $P1254 = root_new ['parrot';'ResizablePMCArray'] + set $P1234, $P1233["blockoid"] + unless_null $P1234, vivify_415 + new $P1234, "Undef" vivify_415: - set $P1255, $P1254[0] - unless_null $P1255, vivify_416 - new $P1255, "Undef" + $P1235 = $P1234."ast"() + store_lex "$past", $P1235 +.annotate 'line', 440 + find_lex $P1236, "$past" + $P1236."blocktype"("declaration") +.annotate 'line', 441 + find_lex $P1237, "$past" + $P1237."control"("return_pir") +.annotate 'line', 442 + find_lex $P1239, "$/" + unless_null $P1239, vivify_416 + $P1239 = root_new ['parrot';'Hash'] vivify_416: - get_hll_global $P1256, ["PAST"], "Op" - $P1257 = $P1256."new"(" .lex \"self\", self" :named("inline")) - $P1255."unshift"($P1257) -.annotate 'line', 455 - find_lex $P1258, "$past" - $P1258."symbol"("self", "lexical" :named("scope")) -.annotate 'line', 456 - find_lex $P1260, "$/" - unless_null $P1260, vivify_417 - $P1260 = root_new ['parrot';'Hash'] + set $P1240, $P1239["deflongname"] + unless_null $P1240, vivify_417 + new $P1240, "Undef" vivify_417: - set $P1261, $P1260["deflongname"] - unless_null $P1261, vivify_418 - new $P1261, "Undef" - vivify_418: - unless $P1261, if_1259_end - .const 'Sub' $P1263 = "77_1275511729.89077" - capture_lex $P1263 - $P1263() - if_1259_end: -.annotate 'line', 460 + unless $P1240, if_1238_end + .const 'Sub' $P1242 = "77_1275600017.58296" + capture_lex $P1242 + $P1242() + if_1238_end: +.annotate 'line', 452 find_lex $P1274, "$/" find_lex $P1275, "$past" $P1276 = $P1274."!make"($P1275) -.annotate 'line', 450 +.annotate 'line', 438 .return ($P1276) - control_1245: + control_1229: .local pmc exception .get_results (exception) getattribute $P1277, exception, "payload" @@ -20967,2165 +21278,2243 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "_block1262" :anon :subid("77_1275511729.89077") :outer("76_1275511729.89077") -.annotate 'line', 457 - new $P1264, "Undef" - .lex "$name", $P1264 - find_lex $P1265, "$/" - unless_null $P1265, vivify_419 - $P1265 = root_new ['parrot';'Hash'] +.sub "_block1241" :anon :subid("77_1275600017.58296") :outer("76_1275600017.58296") +.annotate 'line', 443 + new $P1243, "Undef" + .lex "$name", $P1243 + find_lex $P1244, "$/" + unless_null $P1244, vivify_418 + $P1244 = root_new ['parrot';'Hash'] + vivify_418: + set $P1245, $P1244["sigil"] + unless_null $P1245, vivify_419 + $P1245 = root_new ['parrot';'ResizablePMCArray'] vivify_419: - set $P1266, $P1265["deflongname"] - unless_null $P1266, vivify_420 - $P1266 = root_new ['parrot';'ResizablePMCArray'] + set $P1246, $P1245[0] + unless_null $P1246, vivify_420 + new $P1246, "Undef" vivify_420: - set $P1267, $P1266[0] - unless_null $P1267, vivify_421 - new $P1267, "Undef" + set $S1247, $P1246 + new $P1248, 'String' + set $P1248, $S1247 + find_lex $P1249, "$/" + unless_null $P1249, vivify_421 + $P1249 = root_new ['parrot';'Hash'] vivify_421: - $P1268 = $P1267."ast"() - set $S1269, $P1268 - new $P1270, 'String' - set $P1270, $S1269 - store_lex "$name", $P1270 -.annotate 'line', 458 - find_lex $P1271, "$past" + set $P1250, $P1249["deflongname"] + unless_null $P1250, vivify_422 + $P1250 = root_new ['parrot';'ResizablePMCArray'] + vivify_422: + set $P1251, $P1250[0] + unless_null $P1251, vivify_423 + new $P1251, "Undef" + vivify_423: + $S1252 = $P1251."ast"() + concat $P1253, $P1248, $S1252 + store_lex "$name", $P1253 +.annotate 'line', 444 + find_lex $P1254, "$past" + find_lex $P1255, "$name" + $P1254."name"($P1255) +.annotate 'line', 445 + find_dynamic_lex $P1258, "$*SCOPE" + unless_null $P1258, vivify_424 + get_hll_global $P1258, "$SCOPE" + unless_null $P1258, vivify_425 + die "Contextual $*SCOPE not found" + vivify_425: + vivify_424: + set $S1259, $P1258 + isne $I1260, $S1259, "our" + if $I1260, if_1257 + new $P1256, 'Integer' + set $P1256, $I1260 + goto if_1257_end + if_1257: +.annotate 'line', 446 + get_global $P1261, "@BLOCK" + unless_null $P1261, vivify_426 + $P1261 = root_new ['parrot';'ResizablePMCArray'] + vivify_426: + set $P1262, $P1261[0] + unless_null $P1262, vivify_427 + $P1262 = root_new ['parrot';'ResizablePMCArray'] + vivify_427: + set $P1263, $P1262[0] + unless_null $P1263, vivify_428 + new $P1263, "Undef" + vivify_428: + get_hll_global $P1264, ["PAST"], "Var" + find_lex $P1265, "$name" + find_lex $P1266, "$past" + $P1267 = $P1264."new"($P1265 :named("name"), 1 :named("isdecl"), $P1266 :named("viviself"), "lexical" :named("scope")) + $P1263."push"($P1267) +.annotate 'line', 448 + get_global $P1268, "@BLOCK" + unless_null $P1268, vivify_429 + $P1268 = root_new ['parrot';'ResizablePMCArray'] + vivify_429: + set $P1269, $P1268[0] + unless_null $P1269, vivify_430 + new $P1269, "Undef" + vivify_430: + find_lex $P1270, "$name" + $P1269."symbol"($P1270, "lexical" :named("scope")) +.annotate 'line', 449 + get_hll_global $P1271, ["PAST"], "Var" find_lex $P1272, "$name" - $P1273 = $P1271."name"($P1272) -.annotate 'line', 456 - .return ($P1273) + $P1273 = $P1271."new"($P1272 :named("name")) + store_lex "$past", $P1273 +.annotate 'line', 445 + set $P1256, $P1273 + if_1257_end: +.annotate 'line', 442 + .return ($P1256) .end .namespace ["NQP";"Actions"] -.sub "signature" :subid("78_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "method_def" :subid("78_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_1281 -.annotate 'line', 464 - .const 'Sub' $P1292 = "79_1275511729.89077" - capture_lex $P1292 +.annotate 'line', 456 + .const 'Sub' $P1297 = "79_1275600017.58296" + capture_lex $P1297 new $P1280, 'ExceptionHandler' set_addr $P1280, control_1279 $P1280."handle_types"(57) push_eh $P1280 .lex "self", self .lex "$/", param_1281 -.annotate 'line', 465 +.annotate 'line', 457 new $P1282, "Undef" - .lex "$BLOCKINIT", $P1282 - get_global $P1283, "@BLOCK" - unless_null $P1283, vivify_422 - $P1283 = root_new ['parrot';'ResizablePMCArray'] - vivify_422: - set $P1284, $P1283[0] - unless_null $P1284, vivify_423 - $P1284 = root_new ['parrot';'ResizablePMCArray'] - vivify_423: - set $P1285, $P1284[0] - unless_null $P1285, vivify_424 - new $P1285, "Undef" - vivify_424: - store_lex "$BLOCKINIT", $P1285 + .lex "$past", $P1282 + find_lex $P1283, "$/" + unless_null $P1283, vivify_431 + $P1283 = root_new ['parrot';'Hash'] + vivify_431: + set $P1284, $P1283["blockoid"] + unless_null $P1284, vivify_432 + new $P1284, "Undef" + vivify_432: + $P1285 = $P1284."ast"() + store_lex "$past", $P1285 +.annotate 'line', 458 + find_lex $P1286, "$past" + $P1286."blocktype"("method") +.annotate 'line', 459 + find_lex $P1287, "$past" + $P1287."control"("return_pir") +.annotate 'line', 460 + find_lex $P1288, "$past" + unless_null $P1288, vivify_433 + $P1288 = root_new ['parrot';'ResizablePMCArray'] + vivify_433: + set $P1289, $P1288[0] + unless_null $P1289, vivify_434 + new $P1289, "Undef" + vivify_434: + get_hll_global $P1290, ["PAST"], "Op" + $P1291 = $P1290."new"(" .lex \"self\", self" :named("inline")) + $P1289."unshift"($P1291) +.annotate 'line', 461 + find_lex $P1292, "$past" + $P1292."symbol"("self", "lexical" :named("scope")) +.annotate 'line', 462 + find_lex $P1294, "$/" + unless_null $P1294, vivify_435 + $P1294 = root_new ['parrot';'Hash'] + vivify_435: + set $P1295, $P1294["deflongname"] + unless_null $P1295, vivify_436 + new $P1295, "Undef" + vivify_436: + unless $P1295, if_1293_end + .const 'Sub' $P1297 = "79_1275600017.58296" + capture_lex $P1297 + $P1297() + if_1293_end: .annotate 'line', 466 - find_lex $P1287, "$/" - unless_null $P1287, vivify_425 - $P1287 = root_new ['parrot';'Hash'] - vivify_425: - set $P1288, $P1287["parameter"] - unless_null $P1288, vivify_426 - new $P1288, "Undef" - vivify_426: - defined $I1289, $P1288 - unless $I1289, for_undef_427 - iter $P1286, $P1288 - new $P1299, 'ExceptionHandler' - set_addr $P1299, loop1298_handler - $P1299."handle_types"(64, 66, 65) - push_eh $P1299 - loop1298_test: - unless $P1286, loop1298_done - shift $P1290, $P1286 - loop1298_redo: - .const 'Sub' $P1292 = "79_1275511729.89077" - capture_lex $P1292 - $P1292($P1290) - loop1298_next: - goto loop1298_test - loop1298_handler: - .local pmc exception - .get_results (exception) - getattribute $P1300, exception, 'type' - eq $P1300, 64, loop1298_next - eq $P1300, 66, loop1298_redo - loop1298_done: - pop_eh - for_undef_427: -.annotate 'line', 464 - .return ($P1286) + find_dynamic_lex $P1309, "$*MULTINESS" + unless_null $P1309, vivify_440 + get_hll_global $P1309, "$MULTINESS" + unless_null $P1309, vivify_441 + die "Contextual $*MULTINESS not found" + vivify_441: + vivify_440: + set $S1310, $P1309 + iseq $I1311, $S1310, "multi" + unless $I1311, if_1308_end + find_lex $P1312, "$past" + $P1313 = $P1312."multi"() + $P1313."unshift"("_") + if_1308_end: +.annotate 'line', 467 + find_lex $P1314, "$/" + find_lex $P1315, "$past" + $P1316 = $P1314."!make"($P1315) +.annotate 'line', 456 + .return ($P1316) control_1279: .local pmc exception .get_results (exception) - getattribute $P1301, exception, "payload" - .return ($P1301) + getattribute $P1317, exception, "payload" + .return ($P1317) .end .namespace ["NQP";"Actions"] -.sub "_block1291" :anon :subid("79_1275511729.89077") :outer("78_1275511729.89077") - .param pmc param_1293 -.annotate 'line', 466 - .lex "$_", param_1293 - find_lex $P1294, "$BLOCKINIT" - find_lex $P1295, "$_" - $P1296 = $P1295."ast"() - $P1297 = $P1294."push"($P1296) - .return ($P1297) +.sub "_block1296" :anon :subid("79_1275600017.58296") :outer("78_1275600017.58296") +.annotate 'line', 463 + new $P1298, "Undef" + .lex "$name", $P1298 + find_lex $P1299, "$/" + unless_null $P1299, vivify_437 + $P1299 = root_new ['parrot';'Hash'] + vivify_437: + set $P1300, $P1299["deflongname"] + unless_null $P1300, vivify_438 + $P1300 = root_new ['parrot';'ResizablePMCArray'] + vivify_438: + set $P1301, $P1300[0] + unless_null $P1301, vivify_439 + new $P1301, "Undef" + vivify_439: + $P1302 = $P1301."ast"() + set $S1303, $P1302 + new $P1304, 'String' + set $P1304, $S1303 + store_lex "$name", $P1304 +.annotate 'line', 464 + find_lex $P1305, "$past" + find_lex $P1306, "$name" + $P1307 = $P1305."name"($P1306) +.annotate 'line', 462 + .return ($P1307) .end .namespace ["NQP";"Actions"] -.sub "parameter" :subid("80_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1305 -.annotate 'line', 469 - new $P1304, 'ExceptionHandler' - set_addr $P1304, control_1303 - $P1304."handle_types"(57) - push_eh $P1304 - .lex "self", self - .lex "$/", param_1305 -.annotate 'line', 470 - new $P1306, "Undef" - .lex "$quant", $P1306 +.sub "signature" :subid("80_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1321 .annotate 'line', 471 - new $P1307, "Undef" - .lex "$past", $P1307 -.annotate 'line', 470 - find_lex $P1308, "$/" - unless_null $P1308, vivify_428 - $P1308 = root_new ['parrot';'Hash'] - vivify_428: - set $P1309, $P1308["quant"] - unless_null $P1309, vivify_429 - new $P1309, "Undef" - vivify_429: - store_lex "$quant", $P1309 - find_lex $P1310, "$past" + .const 'Sub' $P1347 = "82_1275600017.58296" + capture_lex $P1347 + .const 'Sub' $P1332 = "81_1275600017.58296" + capture_lex $P1332 + new $P1320, 'ExceptionHandler' + set_addr $P1320, control_1319 + $P1320."handle_types"(57) + push_eh $P1320 + .lex "self", self + .lex "$/", param_1321 .annotate 'line', 472 - find_lex $P1312, "$/" - unless_null $P1312, vivify_430 - $P1312 = root_new ['parrot';'Hash'] - vivify_430: - set $P1313, $P1312["named_param"] - unless_null $P1313, vivify_431 - new $P1313, "Undef" - vivify_431: - if $P1313, if_1311 -.annotate 'line', 479 - find_lex $P1327, "$/" - unless_null $P1327, vivify_432 - $P1327 = root_new ['parrot';'Hash'] - vivify_432: - set $P1328, $P1327["param_var"] - unless_null $P1328, vivify_433 - new $P1328, "Undef" - vivify_433: - $P1329 = $P1328."ast"() - store_lex "$past", $P1329 -.annotate 'line', 480 - find_lex $P1331, "$quant" - set $S1332, $P1331 - iseq $I1333, $S1332, "*" - if $I1333, if_1330 -.annotate 'line', 484 - find_lex $P1342, "$quant" - set $S1343, $P1342 - iseq $I1344, $S1343, "?" - unless $I1344, if_1341_end -.annotate 'line', 485 - find_lex $P1345, "$past" - find_lex $P1346, "$/" - unless_null $P1346, vivify_434 - $P1346 = root_new ['parrot';'Hash'] - vivify_434: - set $P1347, $P1346["param_var"] - unless_null $P1347, vivify_435 - $P1347 = root_new ['parrot';'Hash'] - vivify_435: - set $P1348, $P1347["sigil"] - unless_null $P1348, vivify_436 - new $P1348, "Undef" - vivify_436: - $P1349 = "vivitype"($P1348) - $P1345."viviself"($P1349) - if_1341_end: -.annotate 'line', 484 - goto if_1330_end - if_1330: -.annotate 'line', 481 - find_lex $P1334, "$past" - $P1334."slurpy"(1) -.annotate 'line', 482 - find_lex $P1335, "$past" - find_lex $P1336, "$/" - unless_null $P1336, vivify_437 - $P1336 = root_new ['parrot';'Hash'] - vivify_437: - set $P1337, $P1336["param_var"] - unless_null $P1337, vivify_438 - $P1337 = root_new ['parrot';'Hash'] - vivify_438: - set $P1338, $P1337["sigil"] - unless_null $P1338, vivify_439 - new $P1338, "Undef" - vivify_439: - set $S1339, $P1338 - iseq $I1340, $S1339, "%" - $P1335."named"($I1340) - if_1330_end: -.annotate 'line', 478 - goto if_1311_end - if_1311: -.annotate 'line', 473 - find_lex $P1314, "$/" - unless_null $P1314, vivify_440 - $P1314 = root_new ['parrot';'Hash'] - vivify_440: - set $P1315, $P1314["named_param"] - unless_null $P1315, vivify_441 - new $P1315, "Undef" - vivify_441: - $P1316 = $P1315."ast"() - store_lex "$past", $P1316 -.annotate 'line', 474 - find_lex $P1318, "$quant" - set $S1319, $P1318 - isne $I1320, $S1319, "!" - unless $I1320, if_1317_end -.annotate 'line', 475 - find_lex $P1321, "$past" - find_lex $P1322, "$/" - unless_null $P1322, vivify_442 - $P1322 = root_new ['parrot';'Hash'] + new $P1322, "Undef" + .lex "$BLOCKINIT", $P1322 + get_global $P1323, "@BLOCK" + unless_null $P1323, vivify_442 + $P1323 = root_new ['parrot';'ResizablePMCArray'] vivify_442: - set $P1323, $P1322["named_param"] - unless_null $P1323, vivify_443 - $P1323 = root_new ['parrot';'Hash'] + set $P1324, $P1323[0] + unless_null $P1324, vivify_443 + $P1324 = root_new ['parrot';'ResizablePMCArray'] vivify_443: - set $P1324, $P1323["param_var"] - unless_null $P1324, vivify_444 - $P1324 = root_new ['parrot';'Hash'] - vivify_444: - set $P1325, $P1324["sigil"] - unless_null $P1325, vivify_445 + set $P1325, $P1324[0] + unless_null $P1325, vivify_444 new $P1325, "Undef" + vivify_444: + store_lex "$BLOCKINIT", $P1325 +.annotate 'line', 474 + find_lex $P1327, "$/" + unless_null $P1327, vivify_445 + $P1327 = root_new ['parrot';'Hash'] vivify_445: - $P1326 = "vivitype"($P1325) - $P1321."viviself"($P1326) - if_1317_end: - if_1311_end: -.annotate 'line', 488 - find_lex $P1351, "$/" - unless_null $P1351, vivify_446 - $P1351 = root_new ['parrot';'Hash'] + set $P1328, $P1327["parameter"] + unless_null $P1328, vivify_446 + new $P1328, "Undef" vivify_446: - set $P1352, $P1351["default_value"] - unless_null $P1352, vivify_447 - new $P1352, "Undef" - vivify_447: - unless $P1352, if_1350_end -.annotate 'line', 489 - find_lex $P1354, "$quant" - set $S1355, $P1354 - iseq $I1356, $S1355, "*" - unless $I1356, if_1353_end -.annotate 'line', 490 - find_lex $P1357, "$/" - $P1358 = $P1357."CURSOR"() - $P1358."panic"("Can't put default on slurpy parameter") - if_1353_end: -.annotate 'line', 492 - find_lex $P1360, "$quant" - set $S1361, $P1360 - iseq $I1362, $S1361, "!" - unless $I1362, if_1359_end -.annotate 'line', 493 - find_lex $P1363, "$/" - $P1364 = $P1363."CURSOR"() - $P1364."panic"("Can't put default on required parameter") - if_1359_end: -.annotate 'line', 495 - find_lex $P1365, "$past" - find_lex $P1366, "$/" - unless_null $P1366, vivify_448 - $P1366 = root_new ['parrot';'Hash'] - vivify_448: - set $P1367, $P1366["default_value"] - unless_null $P1367, vivify_449 - $P1367 = root_new ['parrot';'ResizablePMCArray'] + defined $I1329, $P1328 + unless $I1329, for_undef_447 + iter $P1326, $P1328 + new $P1339, 'ExceptionHandler' + set_addr $P1339, loop1338_handler + $P1339."handle_types"(64, 66, 65) + push_eh $P1339 + loop1338_test: + unless $P1326, loop1338_done + shift $P1330, $P1326 + loop1338_redo: + .const 'Sub' $P1332 = "81_1275600017.58296" + capture_lex $P1332 + $P1332($P1330) + loop1338_next: + goto loop1338_test + loop1338_handler: + .local pmc exception + .get_results (exception) + getattribute $P1340, exception, 'type' + eq $P1340, 64, loop1338_next + eq $P1340, 66, loop1338_redo + loop1338_done: + pop_eh + for_undef_447: +.annotate 'line', 477 + find_dynamic_lex $P1343, "$*MULTINESS" + unless_null $P1343, vivify_448 + get_hll_global $P1343, "$MULTINESS" + unless_null $P1343, vivify_449 + die "Contextual $*MULTINESS not found" vivify_449: - set $P1368, $P1367[0] - unless_null $P1368, vivify_450 - $P1368 = root_new ['parrot';'Hash'] - vivify_450: - set $P1369, $P1368["EXPR"] - unless_null $P1369, vivify_451 - new $P1369, "Undef" - vivify_451: - $P1370 = $P1369."ast"() - $P1365."viviself"($P1370) - if_1350_end: -.annotate 'line', 497 - find_lex $P1372, "$past" - $P1373 = $P1372."viviself"() - if $P1373, unless_1371_end - get_global $P1374, "@BLOCK" - unless_null $P1374, vivify_452 - $P1374 = root_new ['parrot';'ResizablePMCArray'] - vivify_452: - set $P1375, $P1374[0] - unless_null $P1375, vivify_453 - new $P1375, "Undef" - vivify_453: - get_global $P1376, "@BLOCK" - unless_null $P1376, vivify_454 - $P1376 = root_new ['parrot';'ResizablePMCArray'] - vivify_454: - set $P1377, $P1376[0] - unless_null $P1377, vivify_455 - new $P1377, "Undef" - vivify_455: - $P1378 = $P1377."arity"() - set $N1379, $P1378 - new $P1380, 'Float' - set $P1380, $N1379 - add $P1381, $P1380, 1 - $P1375."arity"($P1381) - unless_1371_end: -.annotate 'line', 498 - find_lex $P1382, "$/" - find_lex $P1383, "$past" - $P1384 = $P1382."!make"($P1383) -.annotate 'line', 469 - .return ($P1384) - control_1303: + vivify_448: + set $S1344, $P1343 + iseq $I1345, $S1344, "multi" + if $I1345, if_1342 + new $P1341, 'Integer' + set $P1341, $I1345 + goto if_1342_end + if_1342: + .const 'Sub' $P1347 = "82_1275600017.58296" + capture_lex $P1347 + $P1373 = $P1347() + set $P1341, $P1373 + if_1342_end: +.annotate 'line', 471 + .return ($P1341) + control_1319: .local pmc exception .get_results (exception) - getattribute $P1385, exception, "payload" - .return ($P1385) + getattribute $P1374, exception, "payload" + .return ($P1374) .end .namespace ["NQP";"Actions"] -.sub "param_var" :subid("81_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1389 -.annotate 'line', 501 - new $P1388, 'ExceptionHandler' - set_addr $P1388, control_1387 - $P1388."handle_types"(57) - push_eh $P1388 - .lex "self", self - .lex "$/", param_1389 -.annotate 'line', 502 - new $P1390, "Undef" - .lex "$name", $P1390 -.annotate 'line', 503 - new $P1391, "Undef" - .lex "$past", $P1391 -.annotate 'line', 502 - find_lex $P1392, "$/" - set $S1393, $P1392 - new $P1394, 'String' - set $P1394, $S1393 - store_lex "$name", $P1394 -.annotate 'line', 503 - get_hll_global $P1395, ["PAST"], "Var" - find_lex $P1396, "$name" - find_lex $P1397, "$/" - $P1398 = $P1395."new"($P1396 :named("name"), "parameter" :named("scope"), 1 :named("isdecl"), $P1397 :named("node")) - store_lex "$past", $P1398 -.annotate 'line', 505 - get_global $P1399, "@BLOCK" - unless_null $P1399, vivify_456 - $P1399 = root_new ['parrot';'ResizablePMCArray'] - vivify_456: - set $P1400, $P1399[0] - unless_null $P1400, vivify_457 - new $P1400, "Undef" - vivify_457: - find_lex $P1401, "$name" - $P1400."symbol"($P1401, "lexical" :named("scope")) -.annotate 'line', 506 - find_lex $P1402, "$/" - find_lex $P1403, "$past" - $P1404 = $P1402."!make"($P1403) -.annotate 'line', 501 - .return ($P1404) - control_1387: +.sub "_block1331" :anon :subid("81_1275600017.58296") :outer("80_1275600017.58296") + .param pmc param_1333 +.annotate 'line', 474 + .lex "$_", param_1333 + find_lex $P1334, "$BLOCKINIT" + find_lex $P1335, "$_" + $P1336 = $P1335."ast"() + $P1337 = $P1334."push"($P1336) + .return ($P1337) +.end + + +.namespace ["NQP";"Actions"] +.sub "_block1346" :anon :subid("82_1275600017.58296") :outer("80_1275600017.58296") +.annotate 'line', 477 + .const 'Sub' $P1356 = "83_1275600017.58296" + capture_lex $P1356 +.annotate 'line', 478 + $P1348 = root_new ['parrot';'ResizablePMCArray'] + .lex "@params", $P1348 +.annotate 'line', 477 + find_lex $P1349, "@params" +.annotate 'line', 479 + find_lex $P1351, "$BLOCKINIT" + $P1352 = $P1351."list"() + defined $I1353, $P1352 + unless $I1353, for_undef_450 + iter $P1350, $P1352 + new $P1367, 'ExceptionHandler' + set_addr $P1367, loop1366_handler + $P1367."handle_types"(64, 66, 65) + push_eh $P1367 + loop1366_test: + unless $P1350, loop1366_done + shift $P1354, $P1350 + loop1366_redo: + .const 'Sub' $P1356 = "83_1275600017.58296" + capture_lex $P1356 + $P1356($P1354) + loop1366_next: + goto loop1366_test + loop1366_handler: .local pmc exception .get_results (exception) - getattribute $P1405, exception, "payload" - .return ($P1405) + getattribute $P1368, exception, 'type' + eq $P1368, 64, loop1366_next + eq $P1368, 66, loop1366_redo + loop1366_done: + pop_eh + for_undef_450: +.annotate 'line', 482 + get_global $P1369, "@BLOCK" + unless_null $P1369, vivify_451 + $P1369 = root_new ['parrot';'ResizablePMCArray'] + vivify_451: + set $P1370, $P1369[0] + unless_null $P1370, vivify_452 + new $P1370, "Undef" + vivify_452: + find_lex $P1371, "@params" + $P1372 = $P1370."multi"($P1371) +.annotate 'line', 477 + .return ($P1372) .end .namespace ["NQP";"Actions"] -.sub "named_param" :subid("82_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1409 -.annotate 'line', 509 - new $P1408, 'ExceptionHandler' - set_addr $P1408, control_1407 - $P1408."handle_types"(57) - push_eh $P1408 +.sub "_block1355" :anon :subid("83_1275600017.58296") :outer("82_1275600017.58296") + .param pmc param_1357 +.annotate 'line', 479 + .lex "$_", param_1357 +.annotate 'line', 480 + find_lex $P1358, "@params" + find_lex $P1360, "$_" + $P1361 = $P1360."multitype"() + set $P1359, $P1361 + defined $I1363, $P1359 + if $I1363, default_1362 + new $P1364, "String" + assign $P1364, "_" + set $P1359, $P1364 + default_1362: + $P1365 = $P1358."push"($P1359) +.annotate 'line', 479 + .return ($P1365) +.end + + +.namespace ["NQP";"Actions"] +.sub "parameter" :subid("84_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1378 +.annotate 'line', 486 + .const 'Sub' $P1459 = "85_1275600017.58296" + capture_lex $P1459 + new $P1377, 'ExceptionHandler' + set_addr $P1377, control_1376 + $P1377."handle_types"(57) + push_eh $P1377 .lex "self", self - .lex "$/", param_1409 -.annotate 'line', 510 - new $P1410, "Undef" - .lex "$past", $P1410 - find_lex $P1411, "$/" - unless_null $P1411, vivify_458 - $P1411 = root_new ['parrot';'Hash'] + .lex "$/", param_1378 +.annotate 'line', 487 + new $P1379, "Undef" + .lex "$quant", $P1379 +.annotate 'line', 488 + new $P1380, "Undef" + .lex "$past", $P1380 +.annotate 'line', 487 + find_lex $P1381, "$/" + unless_null $P1381, vivify_453 + $P1381 = root_new ['parrot';'Hash'] + vivify_453: + set $P1382, $P1381["quant"] + unless_null $P1382, vivify_454 + new $P1382, "Undef" + vivify_454: + store_lex "$quant", $P1382 + find_lex $P1383, "$past" +.annotate 'line', 489 + find_lex $P1385, "$/" + unless_null $P1385, vivify_455 + $P1385 = root_new ['parrot';'Hash'] + vivify_455: + set $P1386, $P1385["named_param"] + unless_null $P1386, vivify_456 + new $P1386, "Undef" + vivify_456: + if $P1386, if_1384 +.annotate 'line', 496 + find_lex $P1400, "$/" + unless_null $P1400, vivify_457 + $P1400 = root_new ['parrot';'Hash'] + vivify_457: + set $P1401, $P1400["param_var"] + unless_null $P1401, vivify_458 + new $P1401, "Undef" vivify_458: - set $P1412, $P1411["param_var"] - unless_null $P1412, vivify_459 - new $P1412, "Undef" + $P1402 = $P1401."ast"() + store_lex "$past", $P1402 +.annotate 'line', 497 + find_lex $P1404, "$quant" + set $S1405, $P1404 + iseq $I1406, $S1405, "*" + if $I1406, if_1403 +.annotate 'line', 501 + find_lex $P1415, "$quant" + set $S1416, $P1415 + iseq $I1417, $S1416, "?" + unless $I1417, if_1414_end +.annotate 'line', 502 + find_lex $P1418, "$past" + find_lex $P1419, "$/" + unless_null $P1419, vivify_459 + $P1419 = root_new ['parrot';'Hash'] vivify_459: - $P1413 = $P1412."ast"() - store_lex "$past", $P1413 -.annotate 'line', 511 - find_lex $P1414, "$past" - find_lex $P1415, "$/" - unless_null $P1415, vivify_460 - $P1415 = root_new ['parrot';'Hash'] + set $P1420, $P1419["param_var"] + unless_null $P1420, vivify_460 + $P1420 = root_new ['parrot';'Hash'] vivify_460: - set $P1416, $P1415["param_var"] - unless_null $P1416, vivify_461 - $P1416 = root_new ['parrot';'Hash'] + set $P1421, $P1420["sigil"] + unless_null $P1421, vivify_461 + new $P1421, "Undef" vivify_461: - set $P1417, $P1416["name"] - unless_null $P1417, vivify_462 - new $P1417, "Undef" + $P1422 = "vivitype"($P1421) + $P1418."viviself"($P1422) + if_1414_end: +.annotate 'line', 501 + goto if_1403_end + if_1403: +.annotate 'line', 498 + find_lex $P1407, "$past" + $P1407."slurpy"(1) +.annotate 'line', 499 + find_lex $P1408, "$past" + find_lex $P1409, "$/" + unless_null $P1409, vivify_462 + $P1409 = root_new ['parrot';'Hash'] vivify_462: - set $S1418, $P1417 - $P1414."named"($S1418) -.annotate 'line', 512 - find_lex $P1419, "$/" - find_lex $P1420, "$past" - $P1421 = $P1419."!make"($P1420) -.annotate 'line', 509 - .return ($P1421) - control_1407: - .local pmc exception - .get_results (exception) - getattribute $P1422, exception, "payload" - .return ($P1422) -.end - - -.namespace ["NQP";"Actions"] -.sub "regex_declarator" :subid("83_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1426 - .param pmc param_1427 :optional - .param int has_param_1427 :opt_flag -.annotate 'line', 515 - .const 'Sub' $P1497 = "85_1275511729.89077" - capture_lex $P1497 - .const 'Sub' $P1469 = "84_1275511729.89077" - capture_lex $P1469 - new $P1425, 'ExceptionHandler' - set_addr $P1425, control_1424 - $P1425."handle_types"(57) - push_eh $P1425 - .lex "self", self - .lex "$/", param_1426 - if has_param_1427, optparam_463 - new $P1428, "Undef" - set param_1427, $P1428 - optparam_463: - .lex "$key", param_1427 -.annotate 'line', 516 - $P1429 = root_new ['parrot';'ResizablePMCArray'] - .lex "@MODIFIERS", $P1429 -.annotate 'line', 519 - new $P1430, "Undef" - .lex "$name", $P1430 -.annotate 'line', 520 - new $P1431, "Undef" - .lex "$past", $P1431 -.annotate 'line', 516 - - $P1432 = get_hll_global ['Regex';'P6Regex';'Actions'], '@MODIFIERS' - - store_lex "@MODIFIERS", $P1432 -.annotate 'line', 519 - find_lex $P1433, "$/" - unless_null $P1433, vivify_464 - $P1433 = root_new ['parrot';'Hash'] + set $P1410, $P1409["param_var"] + unless_null $P1410, vivify_463 + $P1410 = root_new ['parrot';'Hash'] + vivify_463: + set $P1411, $P1410["sigil"] + unless_null $P1411, vivify_464 + new $P1411, "Undef" vivify_464: - set $P1434, $P1433["deflongname"] - unless_null $P1434, vivify_465 - new $P1434, "Undef" + set $S1412, $P1411 + iseq $I1413, $S1412, "%" + $P1408."named"($I1413) + if_1403_end: +.annotate 'line', 495 + goto if_1384_end + if_1384: +.annotate 'line', 490 + find_lex $P1387, "$/" + unless_null $P1387, vivify_465 + $P1387 = root_new ['parrot';'Hash'] vivify_465: - $P1435 = $P1434."ast"() - set $S1436, $P1435 - new $P1437, 'String' - set $P1437, $S1436 - store_lex "$name", $P1437 - find_lex $P1438, "$past" -.annotate 'line', 521 - find_lex $P1440, "$/" - unless_null $P1440, vivify_466 - $P1440 = root_new ['parrot';'Hash'] + set $P1388, $P1387["named_param"] + unless_null $P1388, vivify_466 + new $P1388, "Undef" vivify_466: - set $P1441, $P1440["proto"] - unless_null $P1441, vivify_467 - new $P1441, "Undef" + $P1389 = $P1388."ast"() + store_lex "$past", $P1389 +.annotate 'line', 491 + find_lex $P1391, "$quant" + set $S1392, $P1391 + isne $I1393, $S1392, "!" + unless $I1393, if_1390_end +.annotate 'line', 492 + find_lex $P1394, "$past" + find_lex $P1395, "$/" + unless_null $P1395, vivify_467 + $P1395 = root_new ['parrot';'Hash'] vivify_467: - if $P1441, if_1439 -.annotate 'line', 548 - find_lex $P1465, "$key" - set $S1466, $P1465 - iseq $I1467, $S1466, "open" - if $I1467, if_1464 -.annotate 'line', 561 - .const 'Sub' $P1497 = "85_1275511729.89077" - capture_lex $P1497 - $P1497() - goto if_1464_end - if_1464: -.annotate 'line', 548 - .const 'Sub' $P1469 = "84_1275511729.89077" - capture_lex $P1469 - $P1469() - if_1464_end: - goto if_1439_end - if_1439: -.annotate 'line', 523 - get_hll_global $P1442, ["PAST"], "Stmts" -.annotate 'line', 524 - get_hll_global $P1443, ["PAST"], "Block" - find_lex $P1444, "$name" -.annotate 'line', 525 - get_hll_global $P1445, ["PAST"], "Op" -.annotate 'line', 526 - get_hll_global $P1446, ["PAST"], "Var" - $P1447 = $P1446."new"("self" :named("name"), "register" :named("scope")) - find_lex $P1448, "$name" - $P1449 = $P1445."new"($P1447, $P1448, "!protoregex" :named("name"), "callmethod" :named("pasttype")) -.annotate 'line', 525 - find_lex $P1450, "$/" - $P1451 = $P1443."new"($P1449, $P1444 :named("name"), "method" :named("blocktype"), 0 :named("lexical"), $P1450 :named("node")) -.annotate 'line', 535 - get_hll_global $P1452, ["PAST"], "Block" - new $P1453, "String" - assign $P1453, "!PREFIX__" - find_lex $P1454, "$name" - concat $P1455, $P1453, $P1454 -.annotate 'line', 536 - get_hll_global $P1456, ["PAST"], "Op" -.annotate 'line', 537 - get_hll_global $P1457, ["PAST"], "Var" - $P1458 = $P1457."new"("self" :named("name"), "register" :named("scope")) - find_lex $P1459, "$name" - $P1460 = $P1456."new"($P1458, $P1459, "!PREFIX__!protoregex" :named("name"), "callmethod" :named("pasttype")) -.annotate 'line', 536 - find_lex $P1461, "$/" - $P1462 = $P1452."new"($P1460, $P1455 :named("name"), "method" :named("blocktype"), 0 :named("lexical"), $P1461 :named("node")) -.annotate 'line', 535 - $P1463 = $P1442."new"($P1451, $P1462) -.annotate 'line', 523 - store_lex "$past", $P1463 - if_1439_end: -.annotate 'line', 575 - find_lex $P1518, "$/" - find_lex $P1519, "$past" - $P1520 = $P1518."!make"($P1519) -.annotate 'line', 515 - .return ($P1520) - control_1424: - .local pmc exception - .get_results (exception) - getattribute $P1521, exception, "payload" - .return ($P1521) -.end - - -.namespace ["NQP";"Actions"] -.sub "_block1496" :anon :subid("85_1275511729.89077") :outer("83_1275511729.89077") -.annotate 'line', 562 - new $P1498, "Undef" - .lex "$regex", $P1498 -.annotate 'line', 563 - get_hll_global $P1499, ["Regex";"P6Regex";"Actions"], "buildsub" - find_lex $P1500, "$/" - unless_null $P1500, vivify_468 - $P1500 = root_new ['parrot';'Hash'] + set $P1396, $P1395["named_param"] + unless_null $P1396, vivify_468 + $P1396 = root_new ['parrot';'Hash'] vivify_468: - set $P1501, $P1500["p6regex"] - unless_null $P1501, vivify_469 - new $P1501, "Undef" + set $P1397, $P1396["param_var"] + unless_null $P1397, vivify_469 + $P1397 = root_new ['parrot';'Hash'] vivify_469: - $P1502 = $P1501."ast"() - get_global $P1503, "@BLOCK" - $P1504 = $P1503."shift"() - $P1505 = $P1499($P1502, $P1504) - store_lex "$regex", $P1505 -.annotate 'line', 564 - find_lex $P1506, "$regex" - find_lex $P1507, "$name" - $P1506."name"($P1507) -.annotate 'line', 566 - get_hll_global $P1508, ["PAST"], "Op" -.annotate 'line', 568 - get_hll_global $P1509, ["PAST"], "Var" - new $P1510, "ResizablePMCArray" - push $P1510, "Regex" - $P1511 = $P1509."new"("Method" :named("name"), $P1510 :named("namespace"), "package" :named("scope")) - find_lex $P1512, "$regex" - $P1513 = $P1508."new"($P1511, $P1512, "callmethod" :named("pasttype"), "new" :named("name")) -.annotate 'line', 566 - store_lex "$past", $P1513 -.annotate 'line', 572 - find_lex $P1514, "$regex" - find_lex $P1515, "$past" - unless_null $P1515, vivify_470 - $P1515 = root_new ['parrot';'Hash'] - store_lex "$past", $P1515 + set $P1398, $P1397["sigil"] + unless_null $P1398, vivify_470 + new $P1398, "Undef" vivify_470: - set $P1515["sink"], $P1514 -.annotate 'line', 573 - find_lex $P1516, "@MODIFIERS" - $P1517 = $P1516."shift"() -.annotate 'line', 561 - .return ($P1517) -.end - - -.namespace ["NQP";"Actions"] -.sub "_block1468" :anon :subid("84_1275511729.89077") :outer("83_1275511729.89077") -.annotate 'line', 549 - $P1470 = root_new ['parrot';'Hash'] - .lex "%h", $P1470 -.annotate 'line', 548 - find_lex $P1471, "%h" -.annotate 'line', 550 - find_lex $P1473, "$/" - unless_null $P1473, vivify_471 - $P1473 = root_new ['parrot';'Hash'] + $P1399 = "vivitype"($P1398) + $P1394."viviself"($P1399) + if_1390_end: + if_1384_end: +.annotate 'line', 505 + find_lex $P1424, "$/" + unless_null $P1424, vivify_471 + $P1424 = root_new ['parrot';'Hash'] vivify_471: - set $P1474, $P1473["sym"] - unless_null $P1474, vivify_472 - new $P1474, "Undef" + set $P1425, $P1424["default_value"] + unless_null $P1425, vivify_472 + new $P1425, "Undef" vivify_472: - set $S1475, $P1474 - iseq $I1476, $S1475, "token" - unless $I1476, if_1472_end - new $P1477, "Integer" - assign $P1477, 1 - find_lex $P1478, "%h" - unless_null $P1478, vivify_473 - $P1478 = root_new ['parrot';'Hash'] - store_lex "%h", $P1478 + unless $P1425, if_1423_end +.annotate 'line', 506 + find_lex $P1427, "$quant" + set $S1428, $P1427 + iseq $I1429, $S1428, "*" + unless $I1429, if_1426_end +.annotate 'line', 507 + find_lex $P1430, "$/" + $P1431 = $P1430."CURSOR"() + $P1431."panic"("Can't put default on slurpy parameter") + if_1426_end: +.annotate 'line', 509 + find_lex $P1433, "$quant" + set $S1434, $P1433 + iseq $I1435, $S1434, "!" + unless $I1435, if_1432_end +.annotate 'line', 510 + find_lex $P1436, "$/" + $P1437 = $P1436."CURSOR"() + $P1437."panic"("Can't put default on required parameter") + if_1432_end: +.annotate 'line', 512 + find_lex $P1438, "$past" + find_lex $P1439, "$/" + unless_null $P1439, vivify_473 + $P1439 = root_new ['parrot';'Hash'] vivify_473: - set $P1478["r"], $P1477 - if_1472_end: -.annotate 'line', 551 - find_lex $P1480, "$/" - unless_null $P1480, vivify_474 - $P1480 = root_new ['parrot';'Hash'] + set $P1440, $P1439["default_value"] + unless_null $P1440, vivify_474 + $P1440 = root_new ['parrot';'ResizablePMCArray'] vivify_474: - set $P1481, $P1480["sym"] - unless_null $P1481, vivify_475 - new $P1481, "Undef" + set $P1441, $P1440[0] + unless_null $P1441, vivify_475 + $P1441 = root_new ['parrot';'Hash'] vivify_475: - set $S1482, $P1481 - iseq $I1483, $S1482, "rule" - unless $I1483, if_1479_end - new $P1484, "Integer" - assign $P1484, 1 - find_lex $P1485, "%h" - unless_null $P1485, vivify_476 - $P1485 = root_new ['parrot';'Hash'] - store_lex "%h", $P1485 + set $P1442, $P1441["EXPR"] + unless_null $P1442, vivify_476 + new $P1442, "Undef" vivify_476: - set $P1485["r"], $P1484 - new $P1486, "Integer" - assign $P1486, 1 - find_lex $P1487, "%h" - unless_null $P1487, vivify_477 - $P1487 = root_new ['parrot';'Hash'] - store_lex "%h", $P1487 + $P1443 = $P1442."ast"() + $P1438."viviself"($P1443) + if_1423_end: +.annotate 'line', 514 + find_lex $P1445, "$past" + $P1446 = $P1445."viviself"() + if $P1446, unless_1444_end + get_global $P1447, "@BLOCK" + unless_null $P1447, vivify_477 + $P1447 = root_new ['parrot';'ResizablePMCArray'] vivify_477: - set $P1487["s"], $P1486 - if_1479_end: -.annotate 'line', 552 - find_lex $P1488, "@MODIFIERS" - find_lex $P1489, "%h" - $P1488."unshift"($P1489) -.annotate 'line', 553 - - $P0 = find_lex '$name' - set_hll_global ['Regex';'P6Regex';'Actions'], '$REGEXNAME', $P0 - -.annotate 'line', 557 - get_global $P1490, "@BLOCK" - unless_null $P1490, vivify_478 - $P1490 = root_new ['parrot';'ResizablePMCArray'] + set $P1448, $P1447[0] + unless_null $P1448, vivify_478 + new $P1448, "Undef" vivify_478: - set $P1491, $P1490[0] - unless_null $P1491, vivify_479 - new $P1491, "Undef" + get_global $P1449, "@BLOCK" + unless_null $P1449, vivify_479 + $P1449 = root_new ['parrot';'ResizablePMCArray'] vivify_479: - $P1491."symbol"(unicode:"$\x{a2}", "lexical" :named("scope")) -.annotate 'line', 558 - get_global $P1492, "@BLOCK" - unless_null $P1492, vivify_480 - $P1492 = root_new ['parrot';'ResizablePMCArray'] + set $P1450, $P1449[0] + unless_null $P1450, vivify_480 + new $P1450, "Undef" vivify_480: - set $P1493, $P1492[0] - unless_null $P1493, vivify_481 - new $P1493, "Undef" + $P1451 = $P1450."arity"() + set $N1452, $P1451 + new $P1453, 'Float' + set $P1453, $N1452 + add $P1454, $P1453, 1 + $P1448."arity"($P1454) + unless_1444_end: +.annotate 'line', 517 + find_lex $P1456, "$/" + unless_null $P1456, vivify_481 + $P1456 = root_new ['parrot';'Hash'] vivify_481: - $P1493."symbol"("$/", "lexical" :named("scope")) -.annotate 'line', 559 - new $P1494, "Exception" - set $P1494['type'], 57 - new $P1495, "Integer" - assign $P1495, 0 - setattribute $P1494, 'payload', $P1495 - throw $P1494 -.annotate 'line', 548 - .return () + set $P1457, $P1456["typename"] + unless_null $P1457, vivify_482 + new $P1457, "Undef" + vivify_482: + unless $P1457, if_1455_end + .const 'Sub' $P1459 = "85_1275600017.58296" + capture_lex $P1459 + $P1459() + if_1455_end: +.annotate 'line', 523 + find_lex $P1483, "$/" + find_lex $P1484, "$past" + $P1485 = $P1483."!make"($P1484) +.annotate 'line', 486 + .return ($P1485) + control_1376: + .local pmc exception + .get_results (exception) + getattribute $P1486, exception, "payload" + .return ($P1486) .end .namespace ["NQP";"Actions"] -.sub "dotty" :subid("86_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1525 -.annotate 'line', 579 - new $P1524, 'ExceptionHandler' - set_addr $P1524, control_1523 - $P1524."handle_types"(57) - push_eh $P1524 - .lex "self", self - .lex "$/", param_1525 -.annotate 'line', 580 - new $P1526, "Undef" - .lex "$past", $P1526 - find_lex $P1529, "$/" - unless_null $P1529, vivify_482 - $P1529 = root_new ['parrot';'Hash'] - vivify_482: - set $P1530, $P1529["args"] - unless_null $P1530, vivify_483 - new $P1530, "Undef" +.sub "_block1458" :anon :subid("85_1275600017.58296") :outer("84_1275600017.58296") +.annotate 'line', 517 + .const 'Sub' $P1471 = "86_1275600017.58296" + capture_lex $P1471 +.annotate 'line', 518 + $P1460 = root_new ['parrot';'ResizablePMCArray'] + .lex "@multitype", $P1460 +.annotate 'line', 517 + find_lex $P1461, "@multitype" +.annotate 'line', 519 + find_lex $P1463, "$/" + unless_null $P1463, vivify_483 + $P1463 = root_new ['parrot';'Hash'] vivify_483: - if $P1530, if_1528 - get_hll_global $P1535, ["PAST"], "Op" - find_lex $P1536, "$/" - $P1537 = $P1535."new"($P1536 :named("node")) - set $P1527, $P1537 - goto if_1528_end - if_1528: - find_lex $P1531, "$/" - unless_null $P1531, vivify_484 - $P1531 = root_new ['parrot';'Hash'] + set $P1464, $P1463["typename"] + unless_null $P1464, vivify_484 + $P1464 = root_new ['parrot';'ResizablePMCArray'] vivify_484: - set $P1532, $P1531["args"] - unless_null $P1532, vivify_485 - $P1532 = root_new ['parrot';'ResizablePMCArray'] + set $P1465, $P1464[0] + unless_null $P1465, vivify_485 + $P1465 = root_new ['parrot';'Hash'] vivify_485: - set $P1533, $P1532[0] - unless_null $P1533, vivify_486 - new $P1533, "Undef" + set $P1466, $P1465["name"] + unless_null $P1466, vivify_486 + $P1466 = root_new ['parrot';'Hash'] vivify_486: - $P1534 = $P1533."ast"() - set $P1527, $P1534 - if_1528_end: - store_lex "$past", $P1527 -.annotate 'line', 581 - find_lex $P1538, "$past" - find_lex $P1541, "$/" - unless_null $P1541, vivify_487 - $P1541 = root_new ['parrot';'Hash'] + set $P1467, $P1466["identifier"] + unless_null $P1467, vivify_487 + new $P1467, "Undef" vivify_487: - set $P1542, $P1541["quote"] - unless_null $P1542, vivify_488 - new $P1542, "Undef" - vivify_488: - if $P1542, if_1540 - find_lex $P1546, "$/" - unless_null $P1546, vivify_489 - $P1546 = root_new ['parrot';'Hash'] - vivify_489: - set $P1547, $P1546["longname"] - unless_null $P1547, vivify_490 - new $P1547, "Undef" - vivify_490: - set $S1548, $P1547 - new $P1539, 'String' - set $P1539, $S1548 - goto if_1540_end - if_1540: - find_lex $P1543, "$/" - unless_null $P1543, vivify_491 - $P1543 = root_new ['parrot';'Hash'] - vivify_491: - set $P1544, $P1543["quote"] - unless_null $P1544, vivify_492 - new $P1544, "Undef" - vivify_492: - $P1545 = $P1544."ast"() - set $P1539, $P1545 - if_1540_end: - $P1538."name"($P1539) -.annotate 'line', 582 - find_lex $P1549, "$past" - $P1549."pasttype"("callmethod") -.annotate 'line', 583 - find_lex $P1550, "$/" - find_lex $P1551, "$past" - $P1552 = $P1550."!make"($P1551) -.annotate 'line', 579 - .return ($P1552) - control_1523: + defined $I1468, $P1467 + unless $I1468, for_undef_488 + iter $P1462, $P1467 + new $P1478, 'ExceptionHandler' + set_addr $P1478, loop1477_handler + $P1478."handle_types"(64, 66, 65) + push_eh $P1478 + loop1477_test: + unless $P1462, loop1477_done + shift $P1469, $P1462 + loop1477_redo: + .const 'Sub' $P1471 = "86_1275600017.58296" + capture_lex $P1471 + $P1471($P1469) + loop1477_next: + goto loop1477_test + loop1477_handler: .local pmc exception .get_results (exception) - getattribute $P1553, exception, "payload" - .return ($P1553) + getattribute $P1479, exception, 'type' + eq $P1479, 64, loop1477_next + eq $P1479, 66, loop1477_redo + loop1477_done: + pop_eh + for_undef_488: +.annotate 'line', 520 + find_lex $P1480, "$past" + find_lex $P1481, "@multitype" + $P1482 = $P1480."multitype"($P1481) +.annotate 'line', 517 + .return ($P1482) .end .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("87_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1557 -.annotate 'line', 588 - new $P1556, 'ExceptionHandler' - set_addr $P1556, control_1555 - $P1556."handle_types"(57) - push_eh $P1556 +.sub "_block1470" :anon :subid("86_1275600017.58296") :outer("85_1275600017.58296") + .param pmc param_1472 +.annotate 'line', 519 + .lex "$_", param_1472 + find_lex $P1473, "@multitype" + find_lex $P1474, "$_" + set $S1475, $P1474 + $P1476 = $P1473."push"($S1475) + .return ($P1476) +.end + + +.namespace ["NQP";"Actions"] +.sub "param_var" :subid("87_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1490 +.annotate 'line', 526 + new $P1489, 'ExceptionHandler' + set_addr $P1489, control_1488 + $P1489."handle_types"(57) + push_eh $P1489 .lex "self", self - .lex "$/", param_1557 -.annotate 'line', 589 - find_lex $P1558, "$/" - get_hll_global $P1559, ["PAST"], "Var" - $P1560 = $P1559."new"("self" :named("name")) - $P1561 = $P1558."!make"($P1560) -.annotate 'line', 588 - .return ($P1561) - control_1555: + .lex "$/", param_1490 +.annotate 'line', 527 + new $P1491, "Undef" + .lex "$name", $P1491 +.annotate 'line', 528 + new $P1492, "Undef" + .lex "$past", $P1492 +.annotate 'line', 527 + find_lex $P1493, "$/" + set $S1494, $P1493 + new $P1495, 'String' + set $P1495, $S1494 + store_lex "$name", $P1495 +.annotate 'line', 528 + get_hll_global $P1496, ["PAST"], "Var" + find_lex $P1497, "$name" + find_lex $P1498, "$/" + $P1499 = $P1496."new"($P1497 :named("name"), "parameter" :named("scope"), 1 :named("isdecl"), $P1498 :named("node")) + store_lex "$past", $P1499 +.annotate 'line', 530 + get_global $P1500, "@BLOCK" + unless_null $P1500, vivify_489 + $P1500 = root_new ['parrot';'ResizablePMCArray'] + vivify_489: + set $P1501, $P1500[0] + unless_null $P1501, vivify_490 + new $P1501, "Undef" + vivify_490: + find_lex $P1502, "$name" + $P1501."symbol"($P1502, "lexical" :named("scope")) +.annotate 'line', 531 + find_lex $P1503, "$/" + find_lex $P1504, "$past" + $P1505 = $P1503."!make"($P1504) +.annotate 'line', 526 + .return ($P1505) + control_1488: .local pmc exception .get_results (exception) - getattribute $P1562, exception, "payload" - .return ($P1562) + getattribute $P1506, exception, "payload" + .return ($P1506) .end .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("88_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1566 -.annotate 'line', 592 - new $P1565, 'ExceptionHandler' - set_addr $P1565, control_1564 - $P1565."handle_types"(57) - push_eh $P1565 +.sub "named_param" :subid("88_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1510 +.annotate 'line', 534 + new $P1509, 'ExceptionHandler' + set_addr $P1509, control_1508 + $P1509."handle_types"(57) + push_eh $P1509 .lex "self", self - .lex "$/", param_1566 -.annotate 'line', 593 - new $P1567, "Undef" - .lex "$past", $P1567 - find_lex $P1568, "$/" - unless_null $P1568, vivify_493 - $P1568 = root_new ['parrot';'Hash'] + .lex "$/", param_1510 +.annotate 'line', 535 + new $P1511, "Undef" + .lex "$past", $P1511 + find_lex $P1512, "$/" + unless_null $P1512, vivify_491 + $P1512 = root_new ['parrot';'Hash'] + vivify_491: + set $P1513, $P1512["param_var"] + unless_null $P1513, vivify_492 + new $P1513, "Undef" + vivify_492: + $P1514 = $P1513."ast"() + store_lex "$past", $P1514 +.annotate 'line', 536 + find_lex $P1515, "$past" + find_lex $P1516, "$/" + unless_null $P1516, vivify_493 + $P1516 = root_new ['parrot';'Hash'] vivify_493: - set $P1569, $P1568["args"] - unless_null $P1569, vivify_494 - new $P1569, "Undef" + set $P1517, $P1516["param_var"] + unless_null $P1517, vivify_494 + $P1517 = root_new ['parrot';'Hash'] vivify_494: - $P1570 = $P1569."ast"() - store_lex "$past", $P1570 -.annotate 'line', 594 - find_lex $P1571, "$past" - find_lex $P1572, "$/" - unless_null $P1572, vivify_495 - $P1572 = root_new ['parrot';'Hash'] + set $P1518, $P1517["name"] + unless_null $P1518, vivify_495 + new $P1518, "Undef" vivify_495: - set $P1573, $P1572["identifier"] - unless_null $P1573, vivify_496 - new $P1573, "Undef" - vivify_496: - set $S1574, $P1573 - $P1571."name"($S1574) -.annotate 'line', 595 - find_lex $P1575, "$/" - find_lex $P1576, "$past" - $P1577 = $P1575."!make"($P1576) -.annotate 'line', 592 - .return ($P1577) - control_1564: + set $S1519, $P1518 + $P1515."named"($S1519) +.annotate 'line', 537 + find_lex $P1520, "$/" + find_lex $P1521, "$past" + $P1522 = $P1520."!make"($P1521) +.annotate 'line', 534 + .return ($P1522) + control_1508: .local pmc exception .get_results (exception) - getattribute $P1578, exception, "payload" - .return ($P1578) + getattribute $P1523, exception, "payload" + .return ($P1523) .end .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("89_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1582 -.annotate 'line', 598 - new $P1581, 'ExceptionHandler' - set_addr $P1581, control_1580 - $P1581."handle_types"(57) - push_eh $P1581 +.sub "regex_declarator" :subid("89_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1527 + .param pmc param_1528 :optional + .param int has_param_1528 :opt_flag +.annotate 'line', 540 + .const 'Sub' $P1598 = "91_1275600017.58296" + capture_lex $P1598 + .const 'Sub' $P1570 = "90_1275600017.58296" + capture_lex $P1570 + new $P1526, 'ExceptionHandler' + set_addr $P1526, control_1525 + $P1526."handle_types"(57) + push_eh $P1526 .lex "self", self - .lex "$/", param_1582 -.annotate 'line', 599 - $P1583 = root_new ['parrot';'ResizablePMCArray'] - .lex "@ns", $P1583 -.annotate 'line', 600 - new $P1584, "Undef" - .lex "$name", $P1584 -.annotate 'line', 602 - new $P1585, "Undef" - .lex "$var", $P1585 -.annotate 'line', 604 - new $P1586, "Undef" - .lex "$past", $P1586 -.annotate 'line', 599 - find_lex $P1587, "$/" - unless_null $P1587, vivify_497 - $P1587 = root_new ['parrot';'Hash'] + .lex "$/", param_1527 + if has_param_1528, optparam_496 + new $P1529, "Undef" + set param_1528, $P1529 + optparam_496: + .lex "$key", param_1528 +.annotate 'line', 541 + $P1530 = root_new ['parrot';'ResizablePMCArray'] + .lex "@MODIFIERS", $P1530 +.annotate 'line', 544 + new $P1531, "Undef" + .lex "$name", $P1531 +.annotate 'line', 545 + new $P1532, "Undef" + .lex "$past", $P1532 +.annotate 'line', 541 + + $P1533 = get_hll_global ['Regex';'P6Regex';'Actions'], '@MODIFIERS' + + store_lex "@MODIFIERS", $P1533 +.annotate 'line', 544 + find_lex $P1534, "$/" + unless_null $P1534, vivify_497 + $P1534 = root_new ['parrot';'Hash'] vivify_497: - set $P1588, $P1587["name"] - unless_null $P1588, vivify_498 - $P1588 = root_new ['parrot';'Hash'] + set $P1535, $P1534["deflongname"] + unless_null $P1535, vivify_498 + new $P1535, "Undef" vivify_498: - set $P1589, $P1588["identifier"] - unless_null $P1589, vivify_499 - new $P1589, "Undef" + $P1536 = $P1535."ast"() + set $S1537, $P1536 + new $P1538, 'String' + set $P1538, $S1537 + store_lex "$name", $P1538 + find_lex $P1539, "$past" +.annotate 'line', 546 + find_lex $P1541, "$/" + unless_null $P1541, vivify_499 + $P1541 = root_new ['parrot';'Hash'] vivify_499: - clone $P1590, $P1589 - store_lex "@ns", $P1590 -.annotate 'line', 600 - find_lex $P1591, "@ns" - $P1592 = $P1591."pop"() - store_lex "$name", $P1592 -.annotate 'line', 601 - find_lex $P1596, "@ns" - if $P1596, if_1595 - set $P1594, $P1596 - goto if_1595_end - if_1595: - find_lex $P1597, "@ns" - unless_null $P1597, vivify_500 - $P1597 = root_new ['parrot';'ResizablePMCArray'] + set $P1542, $P1541["proto"] + unless_null $P1542, vivify_500 + new $P1542, "Undef" vivify_500: - set $P1598, $P1597[0] - unless_null $P1598, vivify_501 - new $P1598, "Undef" + if $P1542, if_1540 +.annotate 'line', 573 + find_lex $P1566, "$key" + set $S1567, $P1566 + iseq $I1568, $S1567, "open" + if $I1568, if_1565 +.annotate 'line', 586 + .const 'Sub' $P1598 = "91_1275600017.58296" + capture_lex $P1598 + $P1598() + goto if_1565_end + if_1565: +.annotate 'line', 573 + .const 'Sub' $P1570 = "90_1275600017.58296" + capture_lex $P1570 + $P1570() + if_1565_end: + goto if_1540_end + if_1540: +.annotate 'line', 548 + get_hll_global $P1543, ["PAST"], "Stmts" +.annotate 'line', 549 + get_hll_global $P1544, ["PAST"], "Block" + find_lex $P1545, "$name" +.annotate 'line', 550 + get_hll_global $P1546, ["PAST"], "Op" +.annotate 'line', 551 + get_hll_global $P1547, ["PAST"], "Var" + $P1548 = $P1547."new"("self" :named("name"), "register" :named("scope")) + find_lex $P1549, "$name" + $P1550 = $P1546."new"($P1548, $P1549, "!protoregex" :named("name"), "callmethod" :named("pasttype")) +.annotate 'line', 550 + find_lex $P1551, "$/" + $P1552 = $P1544."new"($P1550, $P1545 :named("name"), "method" :named("blocktype"), 0 :named("lexical"), $P1551 :named("node")) +.annotate 'line', 560 + get_hll_global $P1553, ["PAST"], "Block" + new $P1554, "String" + assign $P1554, "!PREFIX__" + find_lex $P1555, "$name" + concat $P1556, $P1554, $P1555 +.annotate 'line', 561 + get_hll_global $P1557, ["PAST"], "Op" +.annotate 'line', 562 + get_hll_global $P1558, ["PAST"], "Var" + $P1559 = $P1558."new"("self" :named("name"), "register" :named("scope")) + find_lex $P1560, "$name" + $P1561 = $P1557."new"($P1559, $P1560, "!PREFIX__!protoregex" :named("name"), "callmethod" :named("pasttype")) +.annotate 'line', 561 + find_lex $P1562, "$/" + $P1563 = $P1553."new"($P1561, $P1556 :named("name"), "method" :named("blocktype"), 0 :named("lexical"), $P1562 :named("node")) +.annotate 'line', 560 + $P1564 = $P1543."new"($P1552, $P1563) +.annotate 'line', 548 + store_lex "$past", $P1564 + if_1540_end: +.annotate 'line', 600 + find_lex $P1619, "$/" + find_lex $P1620, "$past" + $P1621 = $P1619."!make"($P1620) +.annotate 'line', 540 + .return ($P1621) + control_1525: + .local pmc exception + .get_results (exception) + getattribute $P1622, exception, "payload" + .return ($P1622) +.end + + +.namespace ["NQP";"Actions"] +.sub "_block1597" :anon :subid("91_1275600017.58296") :outer("89_1275600017.58296") +.annotate 'line', 587 + new $P1599, "Undef" + .lex "$regex", $P1599 +.annotate 'line', 588 + get_hll_global $P1600, ["Regex";"P6Regex";"Actions"], "buildsub" + find_lex $P1601, "$/" + unless_null $P1601, vivify_501 + $P1601 = root_new ['parrot';'Hash'] vivify_501: - set $S1599, $P1598 - iseq $I1600, $S1599, "GLOBAL" - new $P1594, 'Integer' - set $P1594, $I1600 - if_1595_end: - unless $P1594, if_1593_end - find_lex $P1601, "@ns" - $P1601."shift"() - if_1593_end: -.annotate 'line', 603 - get_hll_global $P1602, ["PAST"], "Var" - find_lex $P1603, "$name" - set $S1604, $P1603 - find_lex $P1605, "@ns" - $P1606 = $P1602."new"($S1604 :named("name"), $P1605 :named("namespace"), "package" :named("scope")) - store_lex "$var", $P1606 -.annotate 'line', 604 - find_lex $P1607, "$var" - store_lex "$past", $P1607 -.annotate 'line', 605 - find_lex $P1609, "$/" - unless_null $P1609, vivify_502 - $P1609 = root_new ['parrot';'Hash'] + set $P1602, $P1601["p6regex"] + unless_null $P1602, vivify_502 + new $P1602, "Undef" vivify_502: - set $P1610, $P1609["args"] - unless_null $P1610, vivify_503 - new $P1610, "Undef" - vivify_503: - unless $P1610, if_1608_end -.annotate 'line', 606 - find_lex $P1611, "$/" - unless_null $P1611, vivify_504 - $P1611 = root_new ['parrot';'Hash'] - vivify_504: - set $P1612, $P1611["args"] - unless_null $P1612, vivify_505 - $P1612 = root_new ['parrot';'ResizablePMCArray'] - vivify_505: - set $P1613, $P1612[0] - unless_null $P1613, vivify_506 - new $P1613, "Undef" - vivify_506: - $P1614 = $P1613."ast"() + $P1603 = $P1602."ast"() + get_global $P1604, "@BLOCK" + $P1605 = $P1604."shift"() + $P1606 = $P1600($P1603, $P1605) + store_lex "$regex", $P1606 +.annotate 'line', 589 + find_lex $P1607, "$regex" + find_lex $P1608, "$name" + $P1607."name"($P1608) +.annotate 'line', 591 + get_hll_global $P1609, ["PAST"], "Op" +.annotate 'line', 593 + get_hll_global $P1610, ["PAST"], "Var" + new $P1611, "ResizablePMCArray" + push $P1611, "Regex" + $P1612 = $P1610."new"("Method" :named("name"), $P1611 :named("namespace"), "package" :named("scope")) + find_lex $P1613, "$regex" + $P1614 = $P1609."new"($P1612, $P1613, "callmethod" :named("pasttype"), "new" :named("name")) +.annotate 'line', 591 store_lex "$past", $P1614 -.annotate 'line', 607 - find_lex $P1615, "$past" - find_lex $P1616, "$var" - $P1615."unshift"($P1616) - if_1608_end: -.annotate 'line', 609 - find_lex $P1617, "$/" - find_lex $P1618, "$past" - $P1619 = $P1617."!make"($P1618) +.annotate 'line', 597 + find_lex $P1615, "$regex" + find_lex $P1616, "$past" + unless_null $P1616, vivify_503 + $P1616 = root_new ['parrot';'Hash'] + store_lex "$past", $P1616 + vivify_503: + set $P1616["sink"], $P1615 .annotate 'line', 598 - .return ($P1619) - control_1580: - .local pmc exception - .get_results (exception) - getattribute $P1620, exception, "payload" - .return ($P1620) + find_lex $P1617, "@MODIFIERS" + $P1618 = $P1617."shift"() +.annotate 'line', 586 + .return ($P1618) .end .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("90_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1624 -.annotate 'line', 612 - new $P1623, 'ExceptionHandler' - set_addr $P1623, control_1622 - $P1623."handle_types"(57) - push_eh $P1623 - .lex "self", self - .lex "$/", param_1624 -.annotate 'line', 613 - new $P1625, "Undef" - .lex "$past", $P1625 -.annotate 'line', 614 - new $P1626, "Undef" - .lex "$pirop", $P1626 -.annotate 'line', 613 - find_lex $P1629, "$/" - unless_null $P1629, vivify_507 - $P1629 = root_new ['parrot';'Hash'] +.sub "_block1569" :anon :subid("90_1275600017.58296") :outer("89_1275600017.58296") +.annotate 'line', 574 + $P1571 = root_new ['parrot';'Hash'] + .lex "%h", $P1571 +.annotate 'line', 573 + find_lex $P1572, "%h" +.annotate 'line', 575 + find_lex $P1574, "$/" + unless_null $P1574, vivify_504 + $P1574 = root_new ['parrot';'Hash'] + vivify_504: + set $P1575, $P1574["sym"] + unless_null $P1575, vivify_505 + new $P1575, "Undef" + vivify_505: + set $S1576, $P1575 + iseq $I1577, $S1576, "token" + unless $I1577, if_1573_end + new $P1578, "Integer" + assign $P1578, 1 + find_lex $P1579, "%h" + unless_null $P1579, vivify_506 + $P1579 = root_new ['parrot';'Hash'] + store_lex "%h", $P1579 + vivify_506: + set $P1579["r"], $P1578 + if_1573_end: +.annotate 'line', 576 + find_lex $P1581, "$/" + unless_null $P1581, vivify_507 + $P1581 = root_new ['parrot';'Hash'] vivify_507: - set $P1630, $P1629["args"] - unless_null $P1630, vivify_508 - new $P1630, "Undef" + set $P1582, $P1581["sym"] + unless_null $P1582, vivify_508 + new $P1582, "Undef" vivify_508: - if $P1630, if_1628 - get_hll_global $P1635, ["PAST"], "Op" - find_lex $P1636, "$/" - $P1637 = $P1635."new"($P1636 :named("node")) - set $P1627, $P1637 - goto if_1628_end - if_1628: - find_lex $P1631, "$/" - unless_null $P1631, vivify_509 - $P1631 = root_new ['parrot';'Hash'] + set $S1583, $P1582 + iseq $I1584, $S1583, "rule" + unless $I1584, if_1580_end + new $P1585, "Integer" + assign $P1585, 1 + find_lex $P1586, "%h" + unless_null $P1586, vivify_509 + $P1586 = root_new ['parrot';'Hash'] + store_lex "%h", $P1586 vivify_509: - set $P1632, $P1631["args"] - unless_null $P1632, vivify_510 - $P1632 = root_new ['parrot';'ResizablePMCArray'] + set $P1586["r"], $P1585 + new $P1587, "Integer" + assign $P1587, 1 + find_lex $P1588, "%h" + unless_null $P1588, vivify_510 + $P1588 = root_new ['parrot';'Hash'] + store_lex "%h", $P1588 vivify_510: - set $P1633, $P1632[0] - unless_null $P1633, vivify_511 - new $P1633, "Undef" + set $P1588["s"], $P1587 + if_1580_end: +.annotate 'line', 577 + find_lex $P1589, "@MODIFIERS" + find_lex $P1590, "%h" + $P1589."unshift"($P1590) +.annotate 'line', 578 + + $P0 = find_lex '$name' + set_hll_global ['Regex';'P6Regex';'Actions'], '$REGEXNAME', $P0 + +.annotate 'line', 582 + get_global $P1591, "@BLOCK" + unless_null $P1591, vivify_511 + $P1591 = root_new ['parrot';'ResizablePMCArray'] vivify_511: - $P1634 = $P1633."ast"() - set $P1627, $P1634 - if_1628_end: - store_lex "$past", $P1627 -.annotate 'line', 614 - find_lex $P1638, "$/" - unless_null $P1638, vivify_512 - $P1638 = root_new ['parrot';'Hash'] + set $P1592, $P1591[0] + unless_null $P1592, vivify_512 + new $P1592, "Undef" vivify_512: - set $P1639, $P1638["op"] - unless_null $P1639, vivify_513 - new $P1639, "Undef" + $P1592."symbol"(unicode:"$\x{a2}", "lexical" :named("scope")) +.annotate 'line', 583 + get_global $P1593, "@BLOCK" + unless_null $P1593, vivify_513 + $P1593 = root_new ['parrot';'ResizablePMCArray'] vivify_513: - set $S1640, $P1639 - new $P1641, 'String' - set $P1641, $S1640 - store_lex "$pirop", $P1641 -.annotate 'line', 615 - - $P0 = find_lex '$pirop' - $S0 = $P0 - $P0 = split '__', $S0 - $S0 = join ' ', $P0 - $P1642 = box $S0 - - store_lex "$pirop", $P1642 -.annotate 'line', 622 - find_lex $P1643, "$past" - find_lex $P1644, "$pirop" - $P1643."pirop"($P1644) -.annotate 'line', 623 - find_lex $P1645, "$past" - $P1645."pasttype"("pirop") -.annotate 'line', 624 - find_lex $P1646, "$/" - find_lex $P1647, "$past" - $P1648 = $P1646."!make"($P1647) -.annotate 'line', 612 - .return ($P1648) - control_1622: - .local pmc exception - .get_results (exception) - getattribute $P1649, exception, "payload" - .return ($P1649) -.end - - -.namespace ["NQP";"Actions"] -.sub "args" :subid("91_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1653 -.annotate 'line', 627 - new $P1652, 'ExceptionHandler' - set_addr $P1652, control_1651 - $P1652."handle_types"(57) - push_eh $P1652 - .lex "self", self - .lex "$/", param_1653 - find_lex $P1654, "$/" - find_lex $P1655, "$/" - unless_null $P1655, vivify_514 - $P1655 = root_new ['parrot';'Hash'] + set $P1594, $P1593[0] + unless_null $P1594, vivify_514 + new $P1594, "Undef" vivify_514: - set $P1656, $P1655["arglist"] - unless_null $P1656, vivify_515 - new $P1656, "Undef" - vivify_515: - $P1657 = $P1656."ast"() - $P1658 = $P1654."!make"($P1657) - .return ($P1658) - control_1651: - .local pmc exception - .get_results (exception) - getattribute $P1659, exception, "payload" - .return ($P1659) + $P1594."symbol"("$/", "lexical" :named("scope")) +.annotate 'line', 584 + new $P1595, "Exception" + set $P1595['type'], 57 + new $P1596, "Integer" + assign $P1596, 0 + setattribute $P1595, 'payload', $P1596 + throw $P1595 +.annotate 'line', 573 + .return () .end .namespace ["NQP";"Actions"] -.sub "arglist" :subid("92_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1663 -.annotate 'line', 629 - .const 'Sub' $P1674 = "93_1275511729.89077" - capture_lex $P1674 - new $P1662, 'ExceptionHandler' - set_addr $P1662, control_1661 - $P1662."handle_types"(57) - push_eh $P1662 +.sub "dotty" :subid("92_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1626 +.annotate 'line', 604 + new $P1625, 'ExceptionHandler' + set_addr $P1625, control_1624 + $P1625."handle_types"(57) + push_eh $P1625 .lex "self", self - .lex "$/", param_1663 -.annotate 'line', 630 - new $P1664, "Undef" - .lex "$past", $P1664 -.annotate 'line', 638 - new $P1665, "Undef" - .lex "$i", $P1665 -.annotate 'line', 639 - new $P1666, "Undef" - .lex "$n", $P1666 -.annotate 'line', 630 - get_hll_global $P1667, ["PAST"], "Op" - find_lex $P1668, "$/" - $P1669 = $P1667."new"("call" :named("pasttype"), $P1668 :named("node")) - store_lex "$past", $P1669 -.annotate 'line', 631 - find_lex $P1671, "$/" - unless_null $P1671, vivify_516 - $P1671 = root_new ['parrot';'Hash'] + .lex "$/", param_1626 +.annotate 'line', 605 + new $P1627, "Undef" + .lex "$past", $P1627 + find_lex $P1630, "$/" + unless_null $P1630, vivify_515 + $P1630 = root_new ['parrot';'Hash'] + vivify_515: + set $P1631, $P1630["args"] + unless_null $P1631, vivify_516 + new $P1631, "Undef" vivify_516: - set $P1672, $P1671["EXPR"] - unless_null $P1672, vivify_517 - new $P1672, "Undef" + if $P1631, if_1629 + get_hll_global $P1636, ["PAST"], "Op" + find_lex $P1637, "$/" + $P1638 = $P1636."new"($P1637 :named("node")) + set $P1628, $P1638 + goto if_1629_end + if_1629: + find_lex $P1632, "$/" + unless_null $P1632, vivify_517 + $P1632 = root_new ['parrot';'Hash'] vivify_517: - unless $P1672, if_1670_end - .const 'Sub' $P1674 = "93_1275511729.89077" - capture_lex $P1674 - $P1674() - if_1670_end: -.annotate 'line', 638 - new $P1706, "Integer" - assign $P1706, 0 - store_lex "$i", $P1706 -.annotate 'line', 639 - find_lex $P1707, "$past" - $P1708 = $P1707."list"() - set $N1709, $P1708 - new $P1710, 'Float' - set $P1710, $N1709 - store_lex "$n", $P1710 -.annotate 'line', 640 - new $P1758, 'ExceptionHandler' - set_addr $P1758, loop1757_handler - $P1758."handle_types"(64, 66, 65) - push_eh $P1758 - loop1757_test: - find_lex $P1711, "$i" - set $N1712, $P1711 - find_lex $P1713, "$n" - set $N1714, $P1713 - islt $I1715, $N1712, $N1714 - unless $I1715, loop1757_done - loop1757_redo: -.annotate 'line', 641 - find_lex $P1717, "$i" - set $I1718, $P1717 - find_lex $P1719, "$past" - unless_null $P1719, vivify_521 - $P1719 = root_new ['parrot';'ResizablePMCArray'] + set $P1633, $P1632["args"] + unless_null $P1633, vivify_518 + $P1633 = root_new ['parrot';'ResizablePMCArray'] + vivify_518: + set $P1634, $P1633[0] + unless_null $P1634, vivify_519 + new $P1634, "Undef" + vivify_519: + $P1635 = $P1634."ast"() + set $P1628, $P1635 + if_1629_end: + store_lex "$past", $P1628 +.annotate 'line', 606 + find_lex $P1639, "$past" + find_lex $P1642, "$/" + unless_null $P1642, vivify_520 + $P1642 = root_new ['parrot';'Hash'] + vivify_520: + set $P1643, $P1642["quote"] + unless_null $P1643, vivify_521 + new $P1643, "Undef" vivify_521: - set $P1720, $P1719[$I1718] - unless_null $P1720, vivify_522 - new $P1720, "Undef" + if $P1643, if_1641 + find_lex $P1647, "$/" + unless_null $P1647, vivify_522 + $P1647 = root_new ['parrot';'Hash'] vivify_522: - $S1721 = $P1720."name"() - iseq $I1722, $S1721, "&prefix:<|>" - unless $I1722, if_1716_end -.annotate 'line', 642 - find_lex $P1723, "$i" - set $I1724, $P1723 - find_lex $P1725, "$past" - unless_null $P1725, vivify_523 - $P1725 = root_new ['parrot';'ResizablePMCArray'] + set $P1648, $P1647["longname"] + unless_null $P1648, vivify_523 + new $P1648, "Undef" vivify_523: - set $P1726, $P1725[$I1724] - unless_null $P1726, vivify_524 - $P1726 = root_new ['parrot';'ResizablePMCArray'] + set $S1649, $P1648 + new $P1640, 'String' + set $P1640, $S1649 + goto if_1641_end + if_1641: + find_lex $P1644, "$/" + unless_null $P1644, vivify_524 + $P1644 = root_new ['parrot';'Hash'] vivify_524: - set $P1727, $P1726[0] - unless_null $P1727, vivify_525 - new $P1727, "Undef" + set $P1645, $P1644["quote"] + unless_null $P1645, vivify_525 + new $P1645, "Undef" vivify_525: - find_lex $P1728, "$i" - set $I1729, $P1728 - find_lex $P1730, "$past" - unless_null $P1730, vivify_526 - $P1730 = root_new ['parrot';'ResizablePMCArray'] - store_lex "$past", $P1730 - vivify_526: - set $P1730[$I1729], $P1727 -.annotate 'line', 643 - find_lex $P1731, "$i" - set $I1732, $P1731 - find_lex $P1733, "$past" - unless_null $P1733, vivify_527 - $P1733 = root_new ['parrot';'ResizablePMCArray'] - vivify_527: - set $P1734, $P1733[$I1732] - unless_null $P1734, vivify_528 - new $P1734, "Undef" - vivify_528: - $P1734."flat"(1) -.annotate 'line', 644 - find_lex $P1738, "$i" - set $I1739, $P1738 - find_lex $P1740, "$past" - unless_null $P1740, vivify_529 - $P1740 = root_new ['parrot';'ResizablePMCArray'] - vivify_529: - set $P1741, $P1740[$I1739] - unless_null $P1741, vivify_530 - new $P1741, "Undef" - vivify_530: - get_hll_global $P1742, ["PAST"], "Val" - $P1743 = $P1741."isa"($P1742) - if $P1743, if_1737 - set $P1736, $P1743 - goto if_1737_end - if_1737: -.annotate 'line', 645 - find_lex $P1744, "$i" - set $I1745, $P1744 - find_lex $P1746, "$past" - unless_null $P1746, vivify_531 - $P1746 = root_new ['parrot';'ResizablePMCArray'] - vivify_531: - set $P1747, $P1746[$I1745] - unless_null $P1747, vivify_532 - new $P1747, "Undef" - vivify_532: - $S1748 = $P1747."name"() - substr $S1749, $S1748, 0, 1 - iseq $I1750, $S1749, "%" - new $P1736, 'Integer' - set $P1736, $I1750 - if_1737_end: - unless $P1736, if_1735_end -.annotate 'line', 646 - find_lex $P1751, "$i" - set $I1752, $P1751 - find_lex $P1753, "$past" - unless_null $P1753, vivify_533 - $P1753 = root_new ['parrot';'ResizablePMCArray'] - vivify_533: - set $P1754, $P1753[$I1752] - unless_null $P1754, vivify_534 - new $P1754, "Undef" - vivify_534: - $P1754."named"(1) - if_1735_end: - if_1716_end: -.annotate 'line', 641 - find_lex $P1755, "$i" - clone $P1756, $P1755 - inc $P1755 - loop1757_next: -.annotate 'line', 640 - goto loop1757_test - loop1757_handler: - .local pmc exception - .get_results (exception) - getattribute $P1759, exception, 'type' - eq $P1759, 64, loop1757_next - eq $P1759, 66, loop1757_redo - loop1757_done: - pop_eh -.annotate 'line', 651 - find_lex $P1760, "$/" - find_lex $P1761, "$past" - $P1762 = $P1760."!make"($P1761) -.annotate 'line', 629 - .return ($P1762) - control_1661: + $P1646 = $P1645."ast"() + set $P1640, $P1646 + if_1641_end: + $P1639."name"($P1640) +.annotate 'line', 607 + find_lex $P1650, "$past" + $P1650."pasttype"("callmethod") +.annotate 'line', 608 + find_lex $P1651, "$/" + find_lex $P1652, "$past" + $P1653 = $P1651."!make"($P1652) +.annotate 'line', 604 + .return ($P1653) + control_1624: .local pmc exception .get_results (exception) - getattribute $P1763, exception, "payload" - .return ($P1763) + getattribute $P1654, exception, "payload" + .return ($P1654) .end .namespace ["NQP";"Actions"] -.sub "_block1673" :anon :subid("93_1275511729.89077") :outer("92_1275511729.89077") -.annotate 'line', 631 - .const 'Sub' $P1695 = "94_1275511729.89077" - capture_lex $P1695 -.annotate 'line', 632 - new $P1675, "Undef" - .lex "$expr", $P1675 - find_lex $P1676, "$/" - unless_null $P1676, vivify_518 - $P1676 = root_new ['parrot';'Hash'] - vivify_518: - set $P1677, $P1676["EXPR"] - unless_null $P1677, vivify_519 - new $P1677, "Undef" - vivify_519: - $P1678 = $P1677."ast"() - store_lex "$expr", $P1678 -.annotate 'line', 633 - find_lex $P1683, "$expr" - $S1684 = $P1683."name"() - iseq $I1685, $S1684, "&infix:<,>" - if $I1685, if_1682 - new $P1681, 'Integer' - set $P1681, $I1685 - goto if_1682_end - if_1682: - find_lex $P1686, "$expr" - $P1687 = $P1686."named"() - isfalse $I1688, $P1687 - new $P1681, 'Integer' - set $P1681, $I1688 - if_1682_end: - if $P1681, if_1680 -.annotate 'line', 636 - find_lex $P1703, "$past" - find_lex $P1704, "$expr" - $P1705 = $P1703."push"($P1704) - set $P1679, $P1705 -.annotate 'line', 633 - goto if_1680_end - if_1680: -.annotate 'line', 634 - find_lex $P1690, "$expr" - $P1691 = $P1690."list"() - defined $I1692, $P1691 - unless $I1692, for_undef_520 - iter $P1689, $P1691 - new $P1701, 'ExceptionHandler' - set_addr $P1701, loop1700_handler - $P1701."handle_types"(64, 66, 65) - push_eh $P1701 - loop1700_test: - unless $P1689, loop1700_done - shift $P1693, $P1689 - loop1700_redo: - .const 'Sub' $P1695 = "94_1275511729.89077" - capture_lex $P1695 - $P1695($P1693) - loop1700_next: - goto loop1700_test - loop1700_handler: +.sub "term:sym" :subid("93_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1658 +.annotate 'line', 613 + new $P1657, 'ExceptionHandler' + set_addr $P1657, control_1656 + $P1657."handle_types"(57) + push_eh $P1657 + .lex "self", self + .lex "$/", param_1658 +.annotate 'line', 614 + find_lex $P1659, "$/" + get_hll_global $P1660, ["PAST"], "Var" + $P1661 = $P1660."new"("self" :named("name")) + $P1662 = $P1659."!make"($P1661) +.annotate 'line', 613 + .return ($P1662) + control_1656: .local pmc exception .get_results (exception) - getattribute $P1702, exception, 'type' - eq $P1702, 64, loop1700_next - eq $P1702, 66, loop1700_redo - loop1700_done: - pop_eh - for_undef_520: -.annotate 'line', 633 - set $P1679, $P1689 - if_1680_end: -.annotate 'line', 631 - .return ($P1679) -.end - - -.namespace ["NQP";"Actions"] -.sub "_block1694" :anon :subid("94_1275511729.89077") :outer("93_1275511729.89077") - .param pmc param_1696 -.annotate 'line', 634 - .lex "$_", param_1696 - find_lex $P1697, "$past" - find_lex $P1698, "$_" - $P1699 = $P1697."push"($P1698) - .return ($P1699) + getattribute $P1663, exception, "payload" + .return ($P1663) .end .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("95_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1767 -.annotate 'line', 655 - new $P1766, 'ExceptionHandler' - set_addr $P1766, control_1765 - $P1766."handle_types"(57) - push_eh $P1766 +.sub "term:sym" :subid("94_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1667 +.annotate 'line', 617 + new $P1666, 'ExceptionHandler' + set_addr $P1666, control_1665 + $P1666."handle_types"(57) + push_eh $P1666 .lex "self", self - .lex "$/", param_1767 - find_lex $P1768, "$/" - find_lex $P1769, "$/" - unless_null $P1769, vivify_535 - $P1769 = root_new ['parrot';'Hash'] - vivify_535: - set $P1770, $P1769["value"] - unless_null $P1770, vivify_536 - new $P1770, "Undef" - vivify_536: - $P1771 = $P1770."ast"() - $P1772 = $P1768."!make"($P1771) - .return ($P1772) - control_1765: + .lex "$/", param_1667 +.annotate 'line', 618 + new $P1668, "Undef" + .lex "$past", $P1668 + find_lex $P1669, "$/" + unless_null $P1669, vivify_526 + $P1669 = root_new ['parrot';'Hash'] + vivify_526: + set $P1670, $P1669["args"] + unless_null $P1670, vivify_527 + new $P1670, "Undef" + vivify_527: + $P1671 = $P1670."ast"() + store_lex "$past", $P1671 +.annotate 'line', 619 + find_lex $P1672, "$past" + find_lex $P1673, "$/" + unless_null $P1673, vivify_528 + $P1673 = root_new ['parrot';'Hash'] + vivify_528: + set $P1674, $P1673["identifier"] + unless_null $P1674, vivify_529 + new $P1674, "Undef" + vivify_529: + set $S1675, $P1674 + $P1672."name"($S1675) +.annotate 'line', 620 + find_lex $P1676, "$/" + find_lex $P1677, "$past" + $P1678 = $P1676."!make"($P1677) +.annotate 'line', 617 + .return ($P1678) + control_1665: .local pmc exception .get_results (exception) - getattribute $P1773, exception, "payload" - .return ($P1773) + getattribute $P1679, exception, "payload" + .return ($P1679) .end .namespace ["NQP";"Actions"] -.sub "circumfix:sym<( )>" :subid("96_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1777 -.annotate 'line', 657 - new $P1776, 'ExceptionHandler' - set_addr $P1776, control_1775 - $P1776."handle_types"(57) - push_eh $P1776 +.sub "term:sym" :subid("95_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1683 +.annotate 'line', 623 + new $P1682, 'ExceptionHandler' + set_addr $P1682, control_1681 + $P1682."handle_types"(57) + push_eh $P1682 .lex "self", self - .lex "$/", param_1777 -.annotate 'line', 658 - find_lex $P1778, "$/" -.annotate 'line', 659 - find_lex $P1781, "$/" - unless_null $P1781, vivify_537 - $P1781 = root_new ['parrot';'Hash'] + .lex "$/", param_1683 +.annotate 'line', 624 + $P1684 = root_new ['parrot';'ResizablePMCArray'] + .lex "@ns", $P1684 +.annotate 'line', 625 + new $P1685, "Undef" + .lex "$name", $P1685 +.annotate 'line', 627 + new $P1686, "Undef" + .lex "$var", $P1686 +.annotate 'line', 629 + new $P1687, "Undef" + .lex "$past", $P1687 +.annotate 'line', 624 + find_lex $P1688, "$/" + unless_null $P1688, vivify_530 + $P1688 = root_new ['parrot';'Hash'] + vivify_530: + set $P1689, $P1688["name"] + unless_null $P1689, vivify_531 + $P1689 = root_new ['parrot';'Hash'] + vivify_531: + set $P1690, $P1689["identifier"] + unless_null $P1690, vivify_532 + new $P1690, "Undef" + vivify_532: + clone $P1691, $P1690 + store_lex "@ns", $P1691 +.annotate 'line', 625 + find_lex $P1692, "@ns" + $P1693 = $P1692."pop"() + store_lex "$name", $P1693 +.annotate 'line', 626 + find_lex $P1697, "@ns" + if $P1697, if_1696 + set $P1695, $P1697 + goto if_1696_end + if_1696: + find_lex $P1698, "@ns" + unless_null $P1698, vivify_533 + $P1698 = root_new ['parrot';'ResizablePMCArray'] + vivify_533: + set $P1699, $P1698[0] + unless_null $P1699, vivify_534 + new $P1699, "Undef" + vivify_534: + set $S1700, $P1699 + iseq $I1701, $S1700, "GLOBAL" + new $P1695, 'Integer' + set $P1695, $I1701 + if_1696_end: + unless $P1695, if_1694_end + find_lex $P1702, "@ns" + $P1702."shift"() + if_1694_end: +.annotate 'line', 628 + get_hll_global $P1703, ["PAST"], "Var" + find_lex $P1704, "$name" + set $S1705, $P1704 + find_lex $P1706, "@ns" + $P1707 = $P1703."new"($S1705 :named("name"), $P1706 :named("namespace"), "package" :named("scope")) + store_lex "$var", $P1707 +.annotate 'line', 629 + find_lex $P1708, "$var" + store_lex "$past", $P1708 +.annotate 'line', 630 + find_lex $P1710, "$/" + unless_null $P1710, vivify_535 + $P1710 = root_new ['parrot';'Hash'] + vivify_535: + set $P1711, $P1710["args"] + unless_null $P1711, vivify_536 + new $P1711, "Undef" + vivify_536: + unless $P1711, if_1709_end +.annotate 'line', 631 + find_lex $P1712, "$/" + unless_null $P1712, vivify_537 + $P1712 = root_new ['parrot';'Hash'] vivify_537: - set $P1782, $P1781["EXPR"] - unless_null $P1782, vivify_538 - new $P1782, "Undef" + set $P1713, $P1712["args"] + unless_null $P1713, vivify_538 + $P1713 = root_new ['parrot';'ResizablePMCArray'] vivify_538: - if $P1782, if_1780 -.annotate 'line', 660 - get_hll_global $P1787, ["PAST"], "Op" - find_lex $P1788, "$/" - $P1789 = $P1787."new"("list" :named("pasttype"), $P1788 :named("node")) - set $P1779, $P1789 -.annotate 'line', 659 - goto if_1780_end - if_1780: - find_lex $P1783, "$/" - unless_null $P1783, vivify_539 - $P1783 = root_new ['parrot';'Hash'] + set $P1714, $P1713[0] + unless_null $P1714, vivify_539 + new $P1714, "Undef" vivify_539: - set $P1784, $P1783["EXPR"] - unless_null $P1784, vivify_540 - $P1784 = root_new ['parrot';'ResizablePMCArray'] - vivify_540: - set $P1785, $P1784[0] - unless_null $P1785, vivify_541 - new $P1785, "Undef" - vivify_541: - $P1786 = $P1785."ast"() - set $P1779, $P1786 - if_1780_end: - $P1790 = $P1778."!make"($P1779) -.annotate 'line', 657 - .return ($P1790) - control_1775: + $P1715 = $P1714."ast"() + store_lex "$past", $P1715 +.annotate 'line', 632 + find_lex $P1716, "$past" + find_lex $P1717, "$var" + $P1716."unshift"($P1717) + if_1709_end: +.annotate 'line', 634 + find_lex $P1718, "$/" + find_lex $P1719, "$past" + $P1720 = $P1718."!make"($P1719) +.annotate 'line', 623 + .return ($P1720) + control_1681: .local pmc exception .get_results (exception) - getattribute $P1791, exception, "payload" - .return ($P1791) + getattribute $P1721, exception, "payload" + .return ($P1721) .end .namespace ["NQP";"Actions"] -.sub "circumfix:sym<[ ]>" :subid("97_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1795 -.annotate 'line', 663 - new $P1794, 'ExceptionHandler' - set_addr $P1794, control_1793 - $P1794."handle_types"(57) - push_eh $P1794 +.sub "term:sym" :subid("96_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1725 +.annotate 'line', 637 + new $P1724, 'ExceptionHandler' + set_addr $P1724, control_1723 + $P1724."handle_types"(57) + push_eh $P1724 .lex "self", self - .lex "$/", param_1795 -.annotate 'line', 664 - new $P1796, "Undef" - .lex "$past", $P1796 -.annotate 'line', 663 - find_lex $P1797, "$past" -.annotate 'line', 665 - find_lex $P1799, "$/" - unless_null $P1799, vivify_542 - $P1799 = root_new ['parrot';'Hash'] + .lex "$/", param_1725 +.annotate 'line', 638 + new $P1726, "Undef" + .lex "$past", $P1726 +.annotate 'line', 639 + new $P1727, "Undef" + .lex "$pirop", $P1727 +.annotate 'line', 638 + find_lex $P1730, "$/" + unless_null $P1730, vivify_540 + $P1730 = root_new ['parrot';'Hash'] + vivify_540: + set $P1731, $P1730["args"] + unless_null $P1731, vivify_541 + new $P1731, "Undef" + vivify_541: + if $P1731, if_1729 + get_hll_global $P1736, ["PAST"], "Op" + find_lex $P1737, "$/" + $P1738 = $P1736."new"($P1737 :named("node")) + set $P1728, $P1738 + goto if_1729_end + if_1729: + find_lex $P1732, "$/" + unless_null $P1732, vivify_542 + $P1732 = root_new ['parrot';'Hash'] vivify_542: - set $P1800, $P1799["EXPR"] - unless_null $P1800, vivify_543 - new $P1800, "Undef" + set $P1733, $P1732["args"] + unless_null $P1733, vivify_543 + $P1733 = root_new ['parrot';'ResizablePMCArray'] vivify_543: - if $P1800, if_1798 -.annotate 'line', 672 - get_hll_global $P1812, ["PAST"], "Op" - $P1813 = $P1812."new"("list" :named("pasttype")) - store_lex "$past", $P1813 -.annotate 'line', 671 - goto if_1798_end - if_1798: -.annotate 'line', 666 - find_lex $P1801, "$/" - unless_null $P1801, vivify_544 - $P1801 = root_new ['parrot';'Hash'] + set $P1734, $P1733[0] + unless_null $P1734, vivify_544 + new $P1734, "Undef" vivify_544: - set $P1802, $P1801["EXPR"] - unless_null $P1802, vivify_545 - $P1802 = root_new ['parrot';'ResizablePMCArray'] + $P1735 = $P1734."ast"() + set $P1728, $P1735 + if_1729_end: + store_lex "$past", $P1728 +.annotate 'line', 639 + find_lex $P1739, "$/" + unless_null $P1739, vivify_545 + $P1739 = root_new ['parrot';'Hash'] vivify_545: - set $P1803, $P1802[0] - unless_null $P1803, vivify_546 - new $P1803, "Undef" + set $P1740, $P1739["op"] + unless_null $P1740, vivify_546 + new $P1740, "Undef" vivify_546: - $P1804 = $P1803."ast"() - store_lex "$past", $P1804 -.annotate 'line', 667 - find_lex $P1806, "$past" - $S1807 = $P1806."name"() - isne $I1808, $S1807, "&infix:<,>" - unless $I1808, if_1805_end -.annotate 'line', 668 - get_hll_global $P1809, ["PAST"], "Op" - find_lex $P1810, "$past" - $P1811 = $P1809."new"($P1810, "list" :named("pasttype")) - store_lex "$past", $P1811 - if_1805_end: - if_1798_end: -.annotate 'line', 674 - find_lex $P1814, "$past" - $P1814."name"("&circumfix:<[ ]>") -.annotate 'line', 675 - find_lex $P1815, "$/" - find_lex $P1816, "$past" - $P1817 = $P1815."!make"($P1816) -.annotate 'line', 663 - .return ($P1817) - control_1793: + set $S1741, $P1740 + new $P1742, 'String' + set $P1742, $S1741 + store_lex "$pirop", $P1742 +.annotate 'line', 640 + + $P0 = find_lex '$pirop' + $S0 = $P0 + $P0 = split '__', $S0 + $S0 = join ' ', $P0 + $P1743 = box $S0 + + store_lex "$pirop", $P1743 +.annotate 'line', 647 + find_lex $P1744, "$past" + find_lex $P1745, "$pirop" + $P1744."pirop"($P1745) +.annotate 'line', 648 + find_lex $P1746, "$past" + $P1746."pasttype"("pirop") +.annotate 'line', 649 + find_lex $P1747, "$/" + find_lex $P1748, "$past" + $P1749 = $P1747."!make"($P1748) +.annotate 'line', 637 + .return ($P1749) + control_1723: .local pmc exception .get_results (exception) - getattribute $P1818, exception, "payload" - .return ($P1818) + getattribute $P1750, exception, "payload" + .return ($P1750) .end .namespace ["NQP";"Actions"] -.sub "circumfix:sym" :subid("98_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1822 -.annotate 'line', 678 - new $P1821, 'ExceptionHandler' - set_addr $P1821, control_1820 - $P1821."handle_types"(57) - push_eh $P1821 +.sub "args" :subid("97_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1754 +.annotate 'line', 652 + new $P1753, 'ExceptionHandler' + set_addr $P1753, control_1752 + $P1753."handle_types"(57) + push_eh $P1753 .lex "self", self - .lex "$/", param_1822 - find_lex $P1823, "$/" - find_lex $P1824, "$/" - unless_null $P1824, vivify_547 - $P1824 = root_new ['parrot';'Hash'] + .lex "$/", param_1754 + find_lex $P1755, "$/" + find_lex $P1756, "$/" + unless_null $P1756, vivify_547 + $P1756 = root_new ['parrot';'Hash'] vivify_547: - set $P1825, $P1824["quote_EXPR"] - unless_null $P1825, vivify_548 - new $P1825, "Undef" + set $P1757, $P1756["arglist"] + unless_null $P1757, vivify_548 + new $P1757, "Undef" vivify_548: - $P1826 = $P1825."ast"() - $P1827 = $P1823."!make"($P1826) - .return ($P1827) - control_1820: + $P1758 = $P1757."ast"() + $P1759 = $P1755."!make"($P1758) + .return ($P1759) + control_1752: .local pmc exception .get_results (exception) - getattribute $P1828, exception, "payload" - .return ($P1828) + getattribute $P1760, exception, "payload" + .return ($P1760) .end .namespace ["NQP";"Actions"] -.sub unicode:"circumfix:sym<\x{ab} \x{bb}>" :subid("99_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1832 -.annotate 'line', 679 - new $P1831, 'ExceptionHandler' - set_addr $P1831, control_1830 - $P1831."handle_types"(57) - push_eh $P1831 +.sub "arglist" :subid("98_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1764 +.annotate 'line', 654 + .const 'Sub' $P1775 = "99_1275600017.58296" + capture_lex $P1775 + new $P1763, 'ExceptionHandler' + set_addr $P1763, control_1762 + $P1763."handle_types"(57) + push_eh $P1763 .lex "self", self - .lex "$/", param_1832 - find_lex $P1833, "$/" - find_lex $P1834, "$/" - unless_null $P1834, vivify_549 - $P1834 = root_new ['parrot';'Hash'] + .lex "$/", param_1764 +.annotate 'line', 655 + new $P1765, "Undef" + .lex "$past", $P1765 +.annotate 'line', 663 + new $P1766, "Undef" + .lex "$i", $P1766 +.annotate 'line', 664 + new $P1767, "Undef" + .lex "$n", $P1767 +.annotate 'line', 655 + get_hll_global $P1768, ["PAST"], "Op" + find_lex $P1769, "$/" + $P1770 = $P1768."new"("call" :named("pasttype"), $P1769 :named("node")) + store_lex "$past", $P1770 +.annotate 'line', 656 + find_lex $P1772, "$/" + unless_null $P1772, vivify_549 + $P1772 = root_new ['parrot';'Hash'] vivify_549: - set $P1835, $P1834["quote_EXPR"] - unless_null $P1835, vivify_550 - new $P1835, "Undef" + set $P1773, $P1772["EXPR"] + unless_null $P1773, vivify_550 + new $P1773, "Undef" vivify_550: - $P1836 = $P1835."ast"() - $P1837 = $P1833."!make"($P1836) - .return ($P1837) - control_1830: + unless $P1773, if_1771_end + .const 'Sub' $P1775 = "99_1275600017.58296" + capture_lex $P1775 + $P1775() + if_1771_end: +.annotate 'line', 663 + new $P1807, "Integer" + assign $P1807, 0 + store_lex "$i", $P1807 +.annotate 'line', 664 + find_lex $P1808, "$past" + $P1809 = $P1808."list"() + set $N1810, $P1809 + new $P1811, 'Float' + set $P1811, $N1810 + store_lex "$n", $P1811 +.annotate 'line', 665 + new $P1859, 'ExceptionHandler' + set_addr $P1859, loop1858_handler + $P1859."handle_types"(64, 66, 65) + push_eh $P1859 + loop1858_test: + find_lex $P1812, "$i" + set $N1813, $P1812 + find_lex $P1814, "$n" + set $N1815, $P1814 + islt $I1816, $N1813, $N1815 + unless $I1816, loop1858_done + loop1858_redo: +.annotate 'line', 666 + find_lex $P1818, "$i" + set $I1819, $P1818 + find_lex $P1820, "$past" + unless_null $P1820, vivify_554 + $P1820 = root_new ['parrot';'ResizablePMCArray'] + vivify_554: + set $P1821, $P1820[$I1819] + unless_null $P1821, vivify_555 + new $P1821, "Undef" + vivify_555: + $S1822 = $P1821."name"() + iseq $I1823, $S1822, "&prefix:<|>" + unless $I1823, if_1817_end +.annotate 'line', 667 + find_lex $P1824, "$i" + set $I1825, $P1824 + find_lex $P1826, "$past" + unless_null $P1826, vivify_556 + $P1826 = root_new ['parrot';'ResizablePMCArray'] + vivify_556: + set $P1827, $P1826[$I1825] + unless_null $P1827, vivify_557 + $P1827 = root_new ['parrot';'ResizablePMCArray'] + vivify_557: + set $P1828, $P1827[0] + unless_null $P1828, vivify_558 + new $P1828, "Undef" + vivify_558: + find_lex $P1829, "$i" + set $I1830, $P1829 + find_lex $P1831, "$past" + unless_null $P1831, vivify_559 + $P1831 = root_new ['parrot';'ResizablePMCArray'] + store_lex "$past", $P1831 + vivify_559: + set $P1831[$I1830], $P1828 +.annotate 'line', 668 + find_lex $P1832, "$i" + set $I1833, $P1832 + find_lex $P1834, "$past" + unless_null $P1834, vivify_560 + $P1834 = root_new ['parrot';'ResizablePMCArray'] + vivify_560: + set $P1835, $P1834[$I1833] + unless_null $P1835, vivify_561 + new $P1835, "Undef" + vivify_561: + $P1835."flat"(1) +.annotate 'line', 669 + find_lex $P1839, "$i" + set $I1840, $P1839 + find_lex $P1841, "$past" + unless_null $P1841, vivify_562 + $P1841 = root_new ['parrot';'ResizablePMCArray'] + vivify_562: + set $P1842, $P1841[$I1840] + unless_null $P1842, vivify_563 + new $P1842, "Undef" + vivify_563: + get_hll_global $P1843, ["PAST"], "Val" + $P1844 = $P1842."isa"($P1843) + if $P1844, if_1838 + set $P1837, $P1844 + goto if_1838_end + if_1838: +.annotate 'line', 670 + find_lex $P1845, "$i" + set $I1846, $P1845 + find_lex $P1847, "$past" + unless_null $P1847, vivify_564 + $P1847 = root_new ['parrot';'ResizablePMCArray'] + vivify_564: + set $P1848, $P1847[$I1846] + unless_null $P1848, vivify_565 + new $P1848, "Undef" + vivify_565: + $S1849 = $P1848."name"() + substr $S1850, $S1849, 0, 1 + iseq $I1851, $S1850, "%" + new $P1837, 'Integer' + set $P1837, $I1851 + if_1838_end: + unless $P1837, if_1836_end +.annotate 'line', 671 + find_lex $P1852, "$i" + set $I1853, $P1852 + find_lex $P1854, "$past" + unless_null $P1854, vivify_566 + $P1854 = root_new ['parrot';'ResizablePMCArray'] + vivify_566: + set $P1855, $P1854[$I1853] + unless_null $P1855, vivify_567 + new $P1855, "Undef" + vivify_567: + $P1855."named"(1) + if_1836_end: + if_1817_end: +.annotate 'line', 666 + find_lex $P1856, "$i" + clone $P1857, $P1856 + inc $P1856 + loop1858_next: +.annotate 'line', 665 + goto loop1858_test + loop1858_handler: .local pmc exception .get_results (exception) - getattribute $P1838, exception, "payload" - .return ($P1838) + getattribute $P1860, exception, 'type' + eq $P1860, 64, loop1858_next + eq $P1860, 66, loop1858_redo + loop1858_done: + pop_eh +.annotate 'line', 676 + find_lex $P1861, "$/" + find_lex $P1862, "$past" + $P1863 = $P1861."!make"($P1862) +.annotate 'line', 654 + .return ($P1863) + control_1762: + .local pmc exception + .get_results (exception) + getattribute $P1864, exception, "payload" + .return ($P1864) .end .namespace ["NQP";"Actions"] -.sub "circumfix:sym<{ }>" :subid("100_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1842 -.annotate 'line', 681 - new $P1841, 'ExceptionHandler' - set_addr $P1841, control_1840 - $P1841."handle_types"(57) - push_eh $P1841 - .lex "self", self - .lex "$/", param_1842 -.annotate 'line', 682 - new $P1843, "Undef" - .lex "$past", $P1843 - find_lex $P1846, "$/" - unless_null $P1846, vivify_551 - $P1846 = root_new ['parrot';'Hash'] +.sub "_block1774" :anon :subid("99_1275600017.58296") :outer("98_1275600017.58296") +.annotate 'line', 656 + .const 'Sub' $P1796 = "100_1275600017.58296" + capture_lex $P1796 +.annotate 'line', 657 + new $P1776, "Undef" + .lex "$expr", $P1776 + find_lex $P1777, "$/" + unless_null $P1777, vivify_551 + $P1777 = root_new ['parrot';'Hash'] vivify_551: - set $P1847, $P1846["pblock"] - unless_null $P1847, vivify_552 - $P1847 = root_new ['parrot';'Hash'] + set $P1778, $P1777["EXPR"] + unless_null $P1778, vivify_552 + new $P1778, "Undef" vivify_552: - set $P1848, $P1847["blockoid"] - unless_null $P1848, vivify_553 - $P1848 = root_new ['parrot';'Hash'] - vivify_553: - set $P1849, $P1848["statementlist"] - unless_null $P1849, vivify_554 - $P1849 = root_new ['parrot';'Hash'] - vivify_554: - set $P1850, $P1849["statement"] - unless_null $P1850, vivify_555 - new $P1850, "Undef" - vivify_555: - set $N1851, $P1850 - isgt $I1852, $N1851, 0.0 - if $I1852, if_1845 -.annotate 'line', 684 - $P1856 = "vivitype"("%") - set $P1844, $P1856 -.annotate 'line', 682 - goto if_1845_end - if_1845: -.annotate 'line', 683 - find_lex $P1853, "$/" - unless_null $P1853, vivify_556 - $P1853 = root_new ['parrot';'Hash'] - vivify_556: - set $P1854, $P1853["pblock"] - unless_null $P1854, vivify_557 - new $P1854, "Undef" - vivify_557: - $P1855 = $P1854."ast"() - set $P1844, $P1855 - if_1845_end: - store_lex "$past", $P1844 -.annotate 'line', 685 - new $P1857, "Integer" - assign $P1857, 1 - find_lex $P1858, "$past" - unless_null $P1858, vivify_558 - $P1858 = root_new ['parrot';'Hash'] - store_lex "$past", $P1858 - vivify_558: - set $P1858["bareblock"], $P1857 -.annotate 'line', 686 - find_lex $P1859, "$/" - find_lex $P1860, "$past" - $P1861 = $P1859."!make"($P1860) -.annotate 'line', 681 - .return ($P1861) - control_1840: + $P1779 = $P1778."ast"() + store_lex "$expr", $P1779 +.annotate 'line', 658 + find_lex $P1784, "$expr" + $S1785 = $P1784."name"() + iseq $I1786, $S1785, "&infix:<,>" + if $I1786, if_1783 + new $P1782, 'Integer' + set $P1782, $I1786 + goto if_1783_end + if_1783: + find_lex $P1787, "$expr" + $P1788 = $P1787."named"() + isfalse $I1789, $P1788 + new $P1782, 'Integer' + set $P1782, $I1789 + if_1783_end: + if $P1782, if_1781 +.annotate 'line', 661 + find_lex $P1804, "$past" + find_lex $P1805, "$expr" + $P1806 = $P1804."push"($P1805) + set $P1780, $P1806 +.annotate 'line', 658 + goto if_1781_end + if_1781: +.annotate 'line', 659 + find_lex $P1791, "$expr" + $P1792 = $P1791."list"() + defined $I1793, $P1792 + unless $I1793, for_undef_553 + iter $P1790, $P1792 + new $P1802, 'ExceptionHandler' + set_addr $P1802, loop1801_handler + $P1802."handle_types"(64, 66, 65) + push_eh $P1802 + loop1801_test: + unless $P1790, loop1801_done + shift $P1794, $P1790 + loop1801_redo: + .const 'Sub' $P1796 = "100_1275600017.58296" + capture_lex $P1796 + $P1796($P1794) + loop1801_next: + goto loop1801_test + loop1801_handler: .local pmc exception .get_results (exception) - getattribute $P1862, exception, "payload" - .return ($P1862) + getattribute $P1803, exception, 'type' + eq $P1803, 64, loop1801_next + eq $P1803, 66, loop1801_redo + loop1801_done: + pop_eh + for_undef_553: +.annotate 'line', 658 + set $P1780, $P1790 + if_1781_end: +.annotate 'line', 656 + .return ($P1780) .end .namespace ["NQP";"Actions"] -.sub "circumfix:sym" :subid("101_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1866 -.annotate 'line', 689 - new $P1865, 'ExceptionHandler' - set_addr $P1865, control_1864 - $P1865."handle_types"(57) - push_eh $P1865 +.sub "_block1795" :anon :subid("100_1275600017.58296") :outer("99_1275600017.58296") + .param pmc param_1797 +.annotate 'line', 659 + .lex "$_", param_1797 + find_lex $P1798, "$past" + find_lex $P1799, "$_" + $P1800 = $P1798."push"($P1799) + .return ($P1800) +.end + + +.namespace ["NQP";"Actions"] +.sub "term:sym" :subid("101_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1868 +.annotate 'line', 680 + new $P1867, 'ExceptionHandler' + set_addr $P1867, control_1866 + $P1867."handle_types"(57) + push_eh $P1867 .lex "self", self - .lex "$/", param_1866 -.annotate 'line', 690 - new $P1867, "Undef" - .lex "$name", $P1867 + .lex "$/", param_1868 + find_lex $P1869, "$/" find_lex $P1870, "$/" - unless_null $P1870, vivify_559 + unless_null $P1870, vivify_568 $P1870 = root_new ['parrot';'Hash'] - vivify_559: - set $P1871, $P1870["sigil"] - unless_null $P1871, vivify_560 + vivify_568: + set $P1871, $P1870["value"] + unless_null $P1871, vivify_569 new $P1871, "Undef" - vivify_560: - set $S1872, $P1871 - iseq $I1873, $S1872, "@" - if $I1873, if_1869 -.annotate 'line', 691 - find_lex $P1877, "$/" - unless_null $P1877, vivify_561 - $P1877 = root_new ['parrot';'Hash'] - vivify_561: - set $P1878, $P1877["sigil"] - unless_null $P1878, vivify_562 - new $P1878, "Undef" - vivify_562: - set $S1879, $P1878 - iseq $I1880, $S1879, "%" - if $I1880, if_1876 - new $P1882, "String" - assign $P1882, "item" - set $P1875, $P1882 - goto if_1876_end - if_1876: - new $P1881, "String" - assign $P1881, "hash" - set $P1875, $P1881 - if_1876_end: - set $P1868, $P1875 -.annotate 'line', 690 - goto if_1869_end - if_1869: - new $P1874, "String" - assign $P1874, "list" - set $P1868, $P1874 - if_1869_end: - store_lex "$name", $P1868 -.annotate 'line', 693 - find_lex $P1883, "$/" - get_hll_global $P1884, ["PAST"], "Op" - find_lex $P1885, "$name" - find_lex $P1886, "$/" - unless_null $P1886, vivify_563 - $P1886 = root_new ['parrot';'Hash'] - vivify_563: - set $P1887, $P1886["semilist"] - unless_null $P1887, vivify_564 - new $P1887, "Undef" - vivify_564: - $P1888 = $P1887."ast"() - $P1889 = $P1884."new"($P1888, "callmethod" :named("pasttype"), $P1885 :named("name")) - $P1890 = $P1883."!make"($P1889) -.annotate 'line', 689 - .return ($P1890) - control_1864: + vivify_569: + $P1872 = $P1871."ast"() + $P1873 = $P1869."!make"($P1872) + .return ($P1873) + control_1866: .local pmc exception .get_results (exception) - getattribute $P1891, exception, "payload" - .return ($P1891) + getattribute $P1874, exception, "payload" + .return ($P1874) .end .namespace ["NQP";"Actions"] -.sub "semilist" :subid("102_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1895 -.annotate 'line', 696 - new $P1894, 'ExceptionHandler' - set_addr $P1894, control_1893 - $P1894."handle_types"(57) - push_eh $P1894 +.sub "circumfix:sym<( )>" :subid("102_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1878 +.annotate 'line', 682 + new $P1877, 'ExceptionHandler' + set_addr $P1877, control_1876 + $P1877."handle_types"(57) + push_eh $P1877 .lex "self", self - .lex "$/", param_1895 - find_lex $P1896, "$/" - find_lex $P1897, "$/" - unless_null $P1897, vivify_565 - $P1897 = root_new ['parrot';'Hash'] - vivify_565: - set $P1898, $P1897["statement"] - unless_null $P1898, vivify_566 - new $P1898, "Undef" - vivify_566: - $P1899 = $P1898."ast"() - $P1900 = $P1896."!make"($P1899) - .return ($P1900) - control_1893: + .lex "$/", param_1878 +.annotate 'line', 683 + find_lex $P1879, "$/" +.annotate 'line', 684 + find_lex $P1882, "$/" + unless_null $P1882, vivify_570 + $P1882 = root_new ['parrot';'Hash'] + vivify_570: + set $P1883, $P1882["EXPR"] + unless_null $P1883, vivify_571 + new $P1883, "Undef" + vivify_571: + if $P1883, if_1881 +.annotate 'line', 685 + get_hll_global $P1888, ["PAST"], "Op" + find_lex $P1889, "$/" + $P1890 = $P1888."new"("list" :named("pasttype"), $P1889 :named("node")) + set $P1880, $P1890 +.annotate 'line', 684 + goto if_1881_end + if_1881: + find_lex $P1884, "$/" + unless_null $P1884, vivify_572 + $P1884 = root_new ['parrot';'Hash'] + vivify_572: + set $P1885, $P1884["EXPR"] + unless_null $P1885, vivify_573 + $P1885 = root_new ['parrot';'ResizablePMCArray'] + vivify_573: + set $P1886, $P1885[0] + unless_null $P1886, vivify_574 + new $P1886, "Undef" + vivify_574: + $P1887 = $P1886."ast"() + set $P1880, $P1887 + if_1881_end: + $P1891 = $P1879."!make"($P1880) +.annotate 'line', 682 + .return ($P1891) + control_1876: .local pmc exception .get_results (exception) - getattribute $P1901, exception, "payload" - .return ($P1901) + getattribute $P1892, exception, "payload" + .return ($P1892) .end .namespace ["NQP";"Actions"] -.sub "postcircumfix:sym<[ ]>" :subid("103_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1905 -.annotate 'line', 698 - new $P1904, 'ExceptionHandler' - set_addr $P1904, control_1903 - $P1904."handle_types"(57) - push_eh $P1904 +.sub "circumfix:sym<[ ]>" :subid("103_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1896 +.annotate 'line', 688 + new $P1895, 'ExceptionHandler' + set_addr $P1895, control_1894 + $P1895."handle_types"(57) + push_eh $P1895 .lex "self", self - .lex "$/", param_1905 -.annotate 'line', 699 - find_lex $P1906, "$/" - get_hll_global $P1907, ["PAST"], "Var" - find_lex $P1908, "$/" - unless_null $P1908, vivify_567 - $P1908 = root_new ['parrot';'Hash'] - vivify_567: - set $P1909, $P1908["EXPR"] - unless_null $P1909, vivify_568 - new $P1909, "Undef" - vivify_568: - $P1910 = $P1909."ast"() -.annotate 'line', 701 - $P1911 = "vivitype"("@") - $P1912 = $P1907."new"($P1910, "keyed_int" :named("scope"), "Undef" :named("viviself"), $P1911 :named("vivibase")) + .lex "$/", param_1896 +.annotate 'line', 689 + new $P1897, "Undef" + .lex "$past", $P1897 +.annotate 'line', 688 + find_lex $P1898, "$past" +.annotate 'line', 690 + find_lex $P1900, "$/" + unless_null $P1900, vivify_575 + $P1900 = root_new ['parrot';'Hash'] + vivify_575: + set $P1901, $P1900["EXPR"] + unless_null $P1901, vivify_576 + new $P1901, "Undef" + vivify_576: + if $P1901, if_1899 +.annotate 'line', 697 + get_hll_global $P1913, ["PAST"], "Op" + $P1914 = $P1913."new"("list" :named("pasttype")) + store_lex "$past", $P1914 +.annotate 'line', 696 + goto if_1899_end + if_1899: +.annotate 'line', 691 + find_lex $P1902, "$/" + unless_null $P1902, vivify_577 + $P1902 = root_new ['parrot';'Hash'] + vivify_577: + set $P1903, $P1902["EXPR"] + unless_null $P1903, vivify_578 + $P1903 = root_new ['parrot';'ResizablePMCArray'] + vivify_578: + set $P1904, $P1903[0] + unless_null $P1904, vivify_579 + new $P1904, "Undef" + vivify_579: + $P1905 = $P1904."ast"() + store_lex "$past", $P1905 +.annotate 'line', 692 + find_lex $P1907, "$past" + $S1908 = $P1907."name"() + isne $I1909, $S1908, "&infix:<,>" + unless $I1909, if_1906_end +.annotate 'line', 693 + get_hll_global $P1910, ["PAST"], "Op" + find_lex $P1911, "$past" + $P1912 = $P1910."new"($P1911, "list" :named("pasttype")) + store_lex "$past", $P1912 + if_1906_end: + if_1899_end: .annotate 'line', 699 - $P1913 = $P1906."!make"($P1912) -.annotate 'line', 698 - .return ($P1913) - control_1903: + find_lex $P1915, "$past" + $P1915."name"("&circumfix:<[ ]>") +.annotate 'line', 700 + find_lex $P1916, "$/" + find_lex $P1917, "$past" + $P1918 = $P1916."!make"($P1917) +.annotate 'line', 688 + .return ($P1918) + control_1894: .local pmc exception .get_results (exception) - getattribute $P1914, exception, "payload" - .return ($P1914) + getattribute $P1919, exception, "payload" + .return ($P1919) .end .namespace ["NQP";"Actions"] -.sub "postcircumfix:sym<{ }>" :subid("104_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1918 -.annotate 'line', 704 - new $P1917, 'ExceptionHandler' - set_addr $P1917, control_1916 - $P1917."handle_types"(57) - push_eh $P1917 +.sub "circumfix:sym" :subid("104_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1923 +.annotate 'line', 703 + new $P1922, 'ExceptionHandler' + set_addr $P1922, control_1921 + $P1922."handle_types"(57) + push_eh $P1922 .lex "self", self - .lex "$/", param_1918 -.annotate 'line', 705 - find_lex $P1919, "$/" - get_hll_global $P1920, ["PAST"], "Var" - find_lex $P1921, "$/" - unless_null $P1921, vivify_569 - $P1921 = root_new ['parrot';'Hash'] - vivify_569: - set $P1922, $P1921["EXPR"] - unless_null $P1922, vivify_570 - new $P1922, "Undef" - vivify_570: - $P1923 = $P1922."ast"() -.annotate 'line', 707 - $P1924 = "vivitype"("%") - $P1925 = $P1920."new"($P1923, "keyed" :named("scope"), "Undef" :named("viviself"), $P1924 :named("vivibase")) -.annotate 'line', 705 - $P1926 = $P1919."!make"($P1925) -.annotate 'line', 704 - .return ($P1926) - control_1916: + .lex "$/", param_1923 + find_lex $P1924, "$/" + find_lex $P1925, "$/" + unless_null $P1925, vivify_580 + $P1925 = root_new ['parrot';'Hash'] + vivify_580: + set $P1926, $P1925["quote_EXPR"] + unless_null $P1926, vivify_581 + new $P1926, "Undef" + vivify_581: + $P1927 = $P1926."ast"() + $P1928 = $P1924."!make"($P1927) + .return ($P1928) + control_1921: .local pmc exception .get_results (exception) - getattribute $P1927, exception, "payload" - .return ($P1927) + getattribute $P1929, exception, "payload" + .return ($P1929) .end .namespace ["NQP";"Actions"] -.sub "postcircumfix:sym" :subid("105_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1931 -.annotate 'line', 710 - new $P1930, 'ExceptionHandler' - set_addr $P1930, control_1929 - $P1930."handle_types"(57) - push_eh $P1930 +.sub unicode:"circumfix:sym<\x{ab} \x{bb}>" :subid("105_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1933 +.annotate 'line', 704 + new $P1932, 'ExceptionHandler' + set_addr $P1932, control_1931 + $P1932."handle_types"(57) + push_eh $P1932 .lex "self", self - .lex "$/", param_1931 -.annotate 'line', 711 - find_lex $P1932, "$/" - get_hll_global $P1933, ["PAST"], "Var" + .lex "$/", param_1933 find_lex $P1934, "$/" - unless_null $P1934, vivify_571 - $P1934 = root_new ['parrot';'Hash'] - vivify_571: - set $P1935, $P1934["quote_EXPR"] - unless_null $P1935, vivify_572 - new $P1935, "Undef" - vivify_572: - $P1936 = $P1935."ast"() -.annotate 'line', 713 - $P1937 = "vivitype"("%") - $P1938 = $P1933."new"($P1936, "keyed" :named("scope"), "Undef" :named("viviself"), $P1937 :named("vivibase")) -.annotate 'line', 711 - $P1939 = $P1932."!make"($P1938) -.annotate 'line', 710 - .return ($P1939) - control_1929: - .local pmc exception - .get_results (exception) - getattribute $P1940, exception, "payload" - .return ($P1940) -.end - - -.namespace ["NQP";"Actions"] -.sub "postcircumfix:sym<( )>" :subid("106_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1944 -.annotate 'line', 716 - new $P1943, 'ExceptionHandler' - set_addr $P1943, control_1942 - $P1943."handle_types"(57) - push_eh $P1943 - .lex "self", self - .lex "$/", param_1944 -.annotate 'line', 717 - find_lex $P1945, "$/" - find_lex $P1946, "$/" - unless_null $P1946, vivify_573 - $P1946 = root_new ['parrot';'Hash'] - vivify_573: - set $P1947, $P1946["arglist"] - unless_null $P1947, vivify_574 - new $P1947, "Undef" - vivify_574: - $P1948 = $P1947."ast"() - $P1949 = $P1945."!make"($P1948) -.annotate 'line', 716 - .return ($P1949) - control_1942: + find_lex $P1935, "$/" + unless_null $P1935, vivify_582 + $P1935 = root_new ['parrot';'Hash'] + vivify_582: + set $P1936, $P1935["quote_EXPR"] + unless_null $P1936, vivify_583 + new $P1936, "Undef" + vivify_583: + $P1937 = $P1936."ast"() + $P1938 = $P1934."!make"($P1937) + .return ($P1938) + control_1931: .local pmc exception .get_results (exception) - getattribute $P1950, exception, "payload" - .return ($P1950) + getattribute $P1939, exception, "payload" + .return ($P1939) .end .namespace ["NQP";"Actions"] -.sub "value" :subid("107_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1954 -.annotate 'line', 720 - new $P1953, 'ExceptionHandler' - set_addr $P1953, control_1952 - $P1953."handle_types"(57) - push_eh $P1953 +.sub "circumfix:sym<{ }>" :subid("106_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1943 +.annotate 'line', 706 + new $P1942, 'ExceptionHandler' + set_addr $P1942, control_1941 + $P1942."handle_types"(57) + push_eh $P1942 .lex "self", self - .lex "$/", param_1954 -.annotate 'line', 721 - find_lex $P1955, "$/" - find_lex $P1958, "$/" - unless_null $P1958, vivify_575 - $P1958 = root_new ['parrot';'Hash'] - vivify_575: - set $P1959, $P1958["quote"] - unless_null $P1959, vivify_576 - new $P1959, "Undef" - vivify_576: - if $P1959, if_1957 - find_lex $P1963, "$/" - unless_null $P1963, vivify_577 - $P1963 = root_new ['parrot';'Hash'] - vivify_577: - set $P1964, $P1963["number"] - unless_null $P1964, vivify_578 - new $P1964, "Undef" - vivify_578: - $P1965 = $P1964."ast"() - set $P1956, $P1965 - goto if_1957_end - if_1957: + .lex "$/", param_1943 +.annotate 'line', 707 + new $P1944, "Undef" + .lex "$past", $P1944 + find_lex $P1947, "$/" + unless_null $P1947, vivify_584 + $P1947 = root_new ['parrot';'Hash'] + vivify_584: + set $P1948, $P1947["pblock"] + unless_null $P1948, vivify_585 + $P1948 = root_new ['parrot';'Hash'] + vivify_585: + set $P1949, $P1948["blockoid"] + unless_null $P1949, vivify_586 + $P1949 = root_new ['parrot';'Hash'] + vivify_586: + set $P1950, $P1949["statementlist"] + unless_null $P1950, vivify_587 + $P1950 = root_new ['parrot';'Hash'] + vivify_587: + set $P1951, $P1950["statement"] + unless_null $P1951, vivify_588 + new $P1951, "Undef" + vivify_588: + set $N1952, $P1951 + isgt $I1953, $N1952, 0.0 + if $I1953, if_1946 +.annotate 'line', 709 + $P1957 = "vivitype"("%") + set $P1945, $P1957 +.annotate 'line', 707 + goto if_1946_end + if_1946: +.annotate 'line', 708 + find_lex $P1954, "$/" + unless_null $P1954, vivify_589 + $P1954 = root_new ['parrot';'Hash'] + vivify_589: + set $P1955, $P1954["pblock"] + unless_null $P1955, vivify_590 + new $P1955, "Undef" + vivify_590: + $P1956 = $P1955."ast"() + set $P1945, $P1956 + if_1946_end: + store_lex "$past", $P1945 +.annotate 'line', 710 + new $P1958, "Integer" + assign $P1958, 1 + find_lex $P1959, "$past" + unless_null $P1959, vivify_591 + $P1959 = root_new ['parrot';'Hash'] + store_lex "$past", $P1959 + vivify_591: + set $P1959["bareblock"], $P1958 +.annotate 'line', 711 find_lex $P1960, "$/" - unless_null $P1960, vivify_579 - $P1960 = root_new ['parrot';'Hash'] - vivify_579: - set $P1961, $P1960["quote"] - unless_null $P1961, vivify_580 - new $P1961, "Undef" - vivify_580: - $P1962 = $P1961."ast"() - set $P1956, $P1962 - if_1957_end: - $P1966 = $P1955."!make"($P1956) -.annotate 'line', 720 - .return ($P1966) - control_1952: + find_lex $P1961, "$past" + $P1962 = $P1960."!make"($P1961) +.annotate 'line', 706 + .return ($P1962) + control_1941: .local pmc exception .get_results (exception) - getattribute $P1967, exception, "payload" - .return ($P1967) + getattribute $P1963, exception, "payload" + .return ($P1963) .end .namespace ["NQP";"Actions"] -.sub "number" :subid("108_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1971 -.annotate 'line', 724 - new $P1970, 'ExceptionHandler' - set_addr $P1970, control_1969 - $P1970."handle_types"(57) - push_eh $P1970 +.sub "circumfix:sym" :subid("107_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1967 +.annotate 'line', 714 + new $P1966, 'ExceptionHandler' + set_addr $P1966, control_1965 + $P1966."handle_types"(57) + push_eh $P1966 .lex "self", self - .lex "$/", param_1971 -.annotate 'line', 725 + .lex "$/", param_1967 +.annotate 'line', 715 + new $P1968, "Undef" + .lex "$name", $P1968 + find_lex $P1971, "$/" + unless_null $P1971, vivify_592 + $P1971 = root_new ['parrot';'Hash'] + vivify_592: + set $P1972, $P1971["sigil"] + unless_null $P1972, vivify_593 new $P1972, "Undef" - .lex "$value", $P1972 - find_lex $P1975, "$/" - unless_null $P1975, vivify_581 - $P1975 = root_new ['parrot';'Hash'] - vivify_581: - set $P1976, $P1975["dec_number"] - unless_null $P1976, vivify_582 - new $P1976, "Undef" - vivify_582: - if $P1976, if_1974 - find_lex $P1980, "$/" - unless_null $P1980, vivify_583 - $P1980 = root_new ['parrot';'Hash'] - vivify_583: - set $P1981, $P1980["integer"] - unless_null $P1981, vivify_584 - new $P1981, "Undef" - vivify_584: - $P1982 = $P1981."ast"() - set $P1973, $P1982 - goto if_1974_end - if_1974: - find_lex $P1977, "$/" - unless_null $P1977, vivify_585 - $P1977 = root_new ['parrot';'Hash'] - vivify_585: - set $P1978, $P1977["dec_number"] - unless_null $P1978, vivify_586 - new $P1978, "Undef" - vivify_586: - $P1979 = $P1978."ast"() - set $P1973, $P1979 - if_1974_end: - store_lex "$value", $P1973 -.annotate 'line', 726 + vivify_593: + set $S1973, $P1972 + iseq $I1974, $S1973, "@" + if $I1974, if_1970 +.annotate 'line', 716 + find_lex $P1978, "$/" + unless_null $P1978, vivify_594 + $P1978 = root_new ['parrot';'Hash'] + vivify_594: + set $P1979, $P1978["sigil"] + unless_null $P1979, vivify_595 + new $P1979, "Undef" + vivify_595: + set $S1980, $P1979 + iseq $I1981, $S1980, "%" + if $I1981, if_1977 + new $P1983, "String" + assign $P1983, "item" + set $P1976, $P1983 + goto if_1977_end + if_1977: + new $P1982, "String" + assign $P1982, "hash" + set $P1976, $P1982 + if_1977_end: + set $P1969, $P1976 +.annotate 'line', 715 + goto if_1970_end + if_1970: + new $P1975, "String" + assign $P1975, "list" + set $P1969, $P1975 + if_1970_end: + store_lex "$name", $P1969 +.annotate 'line', 718 find_lex $P1984, "$/" - unless_null $P1984, vivify_587 - $P1984 = root_new ['parrot';'Hash'] - vivify_587: - set $P1985, $P1984["sign"] - unless_null $P1985, vivify_588 - new $P1985, "Undef" - vivify_588: - set $S1986, $P1985 - iseq $I1987, $S1986, "-" - unless $I1987, if_1983_end - find_lex $P1988, "$value" - neg $P1989, $P1988 - store_lex "$value", $P1989 - if_1983_end: -.annotate 'line', 727 - find_lex $P1990, "$/" - get_hll_global $P1991, ["PAST"], "Val" - find_lex $P1992, "$value" - $P1993 = $P1991."new"($P1992 :named("value")) - $P1994 = $P1990."!make"($P1993) -.annotate 'line', 724 - .return ($P1994) - control_1969: + get_hll_global $P1985, ["PAST"], "Op" + find_lex $P1986, "$name" + find_lex $P1987, "$/" + unless_null $P1987, vivify_596 + $P1987 = root_new ['parrot';'Hash'] + vivify_596: + set $P1988, $P1987["semilist"] + unless_null $P1988, vivify_597 + new $P1988, "Undef" + vivify_597: + $P1989 = $P1988."ast"() + $P1990 = $P1985."new"($P1989, "callmethod" :named("pasttype"), $P1986 :named("name")) + $P1991 = $P1984."!make"($P1990) +.annotate 'line', 714 + .return ($P1991) + control_1965: .local pmc exception .get_results (exception) - getattribute $P1995, exception, "payload" - .return ($P1995) + getattribute $P1992, exception, "payload" + .return ($P1992) .end .namespace ["NQP";"Actions"] -.sub "quote:sym" :subid("109_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_1999 -.annotate 'line', 730 - new $P1998, 'ExceptionHandler' - set_addr $P1998, control_1997 - $P1998."handle_types"(57) - push_eh $P1998 +.sub "semilist" :subid("108_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_1996 +.annotate 'line', 721 + new $P1995, 'ExceptionHandler' + set_addr $P1995, control_1994 + $P1995."handle_types"(57) + push_eh $P1995 .lex "self", self - .lex "$/", param_1999 - find_lex $P2000, "$/" - find_lex $P2001, "$/" - unless_null $P2001, vivify_589 - $P2001 = root_new ['parrot';'Hash'] - vivify_589: - set $P2002, $P2001["quote_EXPR"] - unless_null $P2002, vivify_590 - new $P2002, "Undef" - vivify_590: - $P2003 = $P2002."ast"() - $P2004 = $P2000."!make"($P2003) - .return ($P2004) - control_1997: + .lex "$/", param_1996 + find_lex $P1997, "$/" + find_lex $P1998, "$/" + unless_null $P1998, vivify_598 + $P1998 = root_new ['parrot';'Hash'] + vivify_598: + set $P1999, $P1998["statement"] + unless_null $P1999, vivify_599 + new $P1999, "Undef" + vivify_599: + $P2000 = $P1999."ast"() + $P2001 = $P1997."!make"($P2000) + .return ($P2001) + control_1994: .local pmc exception .get_results (exception) - getattribute $P2005, exception, "payload" - .return ($P2005) + getattribute $P2002, exception, "payload" + .return ($P2002) .end .namespace ["NQP";"Actions"] -.sub "quote:sym" :subid("110_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2009 -.annotate 'line', 731 - new $P2008, 'ExceptionHandler' - set_addr $P2008, control_2007 - $P2008."handle_types"(57) - push_eh $P2008 +.sub "postcircumfix:sym<[ ]>" :subid("109_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2006 +.annotate 'line', 723 + new $P2005, 'ExceptionHandler' + set_addr $P2005, control_2004 + $P2005."handle_types"(57) + push_eh $P2005 .lex "self", self - .lex "$/", param_2009 - find_lex $P2010, "$/" - find_lex $P2011, "$/" - unless_null $P2011, vivify_591 - $P2011 = root_new ['parrot';'Hash'] - vivify_591: - set $P2012, $P2011["quote_EXPR"] - unless_null $P2012, vivify_592 - new $P2012, "Undef" - vivify_592: - $P2013 = $P2012."ast"() - $P2014 = $P2010."!make"($P2013) + .lex "$/", param_2006 +.annotate 'line', 724 + find_lex $P2007, "$/" + get_hll_global $P2008, ["PAST"], "Var" + find_lex $P2009, "$/" + unless_null $P2009, vivify_600 + $P2009 = root_new ['parrot';'Hash'] + vivify_600: + set $P2010, $P2009["EXPR"] + unless_null $P2010, vivify_601 + new $P2010, "Undef" + vivify_601: + $P2011 = $P2010."ast"() +.annotate 'line', 726 + $P2012 = "vivitype"("@") + $P2013 = $P2008."new"($P2011, "keyed_int" :named("scope"), "Undef" :named("viviself"), $P2012 :named("vivibase")) +.annotate 'line', 724 + $P2014 = $P2007."!make"($P2013) +.annotate 'line', 723 .return ($P2014) - control_2007: + control_2004: .local pmc exception .get_results (exception) getattribute $P2015, exception, "payload" @@ -23134,233 +23523,237 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "quote:sym" :subid("111_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "postcircumfix:sym<{ }>" :subid("110_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_2019 -.annotate 'line', 732 +.annotate 'line', 729 new $P2018, 'ExceptionHandler' set_addr $P2018, control_2017 $P2018."handle_types"(57) push_eh $P2018 .lex "self", self .lex "$/", param_2019 +.annotate 'line', 730 find_lex $P2020, "$/" - find_lex $P2021, "$/" - unless_null $P2021, vivify_593 - $P2021 = root_new ['parrot';'Hash'] - vivify_593: - set $P2022, $P2021["quote_EXPR"] - unless_null $P2022, vivify_594 - new $P2022, "Undef" - vivify_594: - $P2023 = $P2022."ast"() - $P2024 = $P2020."!make"($P2023) - .return ($P2024) + get_hll_global $P2021, ["PAST"], "Var" + find_lex $P2022, "$/" + unless_null $P2022, vivify_602 + $P2022 = root_new ['parrot';'Hash'] + vivify_602: + set $P2023, $P2022["EXPR"] + unless_null $P2023, vivify_603 + new $P2023, "Undef" + vivify_603: + $P2024 = $P2023."ast"() +.annotate 'line', 732 + $P2025 = "vivitype"("%") + $P2026 = $P2021."new"($P2024, "keyed" :named("scope"), "Undef" :named("viviself"), $P2025 :named("vivibase")) +.annotate 'line', 730 + $P2027 = $P2020."!make"($P2026) +.annotate 'line', 729 + .return ($P2027) control_2017: .local pmc exception .get_results (exception) - getattribute $P2025, exception, "payload" - .return ($P2025) + getattribute $P2028, exception, "payload" + .return ($P2028) .end .namespace ["NQP";"Actions"] -.sub "quote:sym" :subid("112_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2029 -.annotate 'line', 733 - new $P2028, 'ExceptionHandler' - set_addr $P2028, control_2027 - $P2028."handle_types"(57) - push_eh $P2028 +.sub "postcircumfix:sym" :subid("111_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2032 +.annotate 'line', 735 + new $P2031, 'ExceptionHandler' + set_addr $P2031, control_2030 + $P2031."handle_types"(57) + push_eh $P2031 .lex "self", self - .lex "$/", param_2029 - find_lex $P2030, "$/" - find_lex $P2031, "$/" - unless_null $P2031, vivify_595 - $P2031 = root_new ['parrot';'Hash'] - vivify_595: - set $P2032, $P2031["quote_EXPR"] - unless_null $P2032, vivify_596 - new $P2032, "Undef" - vivify_596: - $P2033 = $P2032."ast"() - $P2034 = $P2030."!make"($P2033) - .return ($P2034) - control_2027: + .lex "$/", param_2032 +.annotate 'line', 736 + find_lex $P2033, "$/" + get_hll_global $P2034, ["PAST"], "Var" + find_lex $P2035, "$/" + unless_null $P2035, vivify_604 + $P2035 = root_new ['parrot';'Hash'] + vivify_604: + set $P2036, $P2035["quote_EXPR"] + unless_null $P2036, vivify_605 + new $P2036, "Undef" + vivify_605: + $P2037 = $P2036."ast"() +.annotate 'line', 738 + $P2038 = "vivitype"("%") + $P2039 = $P2034."new"($P2037, "keyed" :named("scope"), "Undef" :named("viviself"), $P2038 :named("vivibase")) +.annotate 'line', 736 + $P2040 = $P2033."!make"($P2039) +.annotate 'line', 735 + .return ($P2040) + control_2030: .local pmc exception .get_results (exception) - getattribute $P2035, exception, "payload" - .return ($P2035) + getattribute $P2041, exception, "payload" + .return ($P2041) .end .namespace ["NQP";"Actions"] -.sub "quote:sym" :subid("113_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2039 -.annotate 'line', 734 - new $P2038, 'ExceptionHandler' - set_addr $P2038, control_2037 - $P2038."handle_types"(57) - push_eh $P2038 +.sub "postcircumfix:sym<( )>" :subid("112_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2045 +.annotate 'line', 741 + new $P2044, 'ExceptionHandler' + set_addr $P2044, control_2043 + $P2044."handle_types"(57) + push_eh $P2044 .lex "self", self - .lex "$/", param_2039 - find_lex $P2040, "$/" - find_lex $P2041, "$/" - unless_null $P2041, vivify_597 - $P2041 = root_new ['parrot';'Hash'] - vivify_597: - set $P2042, $P2041["quote_EXPR"] - unless_null $P2042, vivify_598 - new $P2042, "Undef" - vivify_598: - $P2043 = $P2042."ast"() - $P2044 = $P2040."!make"($P2043) - .return ($P2044) - control_2037: + .lex "$/", param_2045 +.annotate 'line', 742 + find_lex $P2046, "$/" + find_lex $P2047, "$/" + unless_null $P2047, vivify_606 + $P2047 = root_new ['parrot';'Hash'] + vivify_606: + set $P2048, $P2047["arglist"] + unless_null $P2048, vivify_607 + new $P2048, "Undef" + vivify_607: + $P2049 = $P2048."ast"() + $P2050 = $P2046."!make"($P2049) +.annotate 'line', 741 + .return ($P2050) + control_2043: .local pmc exception .get_results (exception) - getattribute $P2045, exception, "payload" - .return ($P2045) + getattribute $P2051, exception, "payload" + .return ($P2051) .end .namespace ["NQP";"Actions"] -.sub "quote:sym" :subid("114_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2049 -.annotate 'line', 735 - new $P2048, 'ExceptionHandler' - set_addr $P2048, control_2047 - $P2048."handle_types"(57) - push_eh $P2048 +.sub "value" :subid("113_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2055 +.annotate 'line', 745 + new $P2054, 'ExceptionHandler' + set_addr $P2054, control_2053 + $P2054."handle_types"(57) + push_eh $P2054 .lex "self", self - .lex "$/", param_2049 -.annotate 'line', 736 - find_lex $P2050, "$/" - get_hll_global $P2051, ["PAST"], "Op" - find_lex $P2052, "$/" - unless_null $P2052, vivify_599 - $P2052 = root_new ['parrot';'Hash'] - vivify_599: - set $P2053, $P2052["quote_EXPR"] - unless_null $P2053, vivify_600 - new $P2053, "Undef" - vivify_600: - $P2054 = $P2053."ast"() - $P2055 = $P2054."value"() + .lex "$/", param_2055 +.annotate 'line', 746 find_lex $P2056, "$/" - $P2057 = $P2051."new"($P2055 :named("inline"), "inline" :named("pasttype"), $P2056 :named("node")) - $P2058 = $P2050."!make"($P2057) -.annotate 'line', 735 - .return ($P2058) - control_2047: + find_lex $P2059, "$/" + unless_null $P2059, vivify_608 + $P2059 = root_new ['parrot';'Hash'] + vivify_608: + set $P2060, $P2059["quote"] + unless_null $P2060, vivify_609 + new $P2060, "Undef" + vivify_609: + if $P2060, if_2058 + find_lex $P2064, "$/" + unless_null $P2064, vivify_610 + $P2064 = root_new ['parrot';'Hash'] + vivify_610: + set $P2065, $P2064["number"] + unless_null $P2065, vivify_611 + new $P2065, "Undef" + vivify_611: + $P2066 = $P2065."ast"() + set $P2057, $P2066 + goto if_2058_end + if_2058: + find_lex $P2061, "$/" + unless_null $P2061, vivify_612 + $P2061 = root_new ['parrot';'Hash'] + vivify_612: + set $P2062, $P2061["quote"] + unless_null $P2062, vivify_613 + new $P2062, "Undef" + vivify_613: + $P2063 = $P2062."ast"() + set $P2057, $P2063 + if_2058_end: + $P2067 = $P2056."!make"($P2057) +.annotate 'line', 745 + .return ($P2067) + control_2053: .local pmc exception .get_results (exception) - getattribute $P2059, exception, "payload" - .return ($P2059) + getattribute $P2068, exception, "payload" + .return ($P2068) .end .namespace ["NQP";"Actions"] -.sub "quote:sym" :subid("115_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2063 - .param pmc param_2064 :optional - .param int has_param_2064 :opt_flag -.annotate 'line', 741 - new $P2062, 'ExceptionHandler' - set_addr $P2062, control_2061 - $P2062."handle_types"(57) - push_eh $P2062 +.sub "number" :subid("114_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2072 +.annotate 'line', 749 + new $P2071, 'ExceptionHandler' + set_addr $P2071, control_2070 + $P2071."handle_types"(57) + push_eh $P2071 .lex "self", self - .lex "$/", param_2063 - if has_param_2064, optparam_601 - new $P2065, "Undef" - set param_2064, $P2065 - optparam_601: - .lex "$key", param_2064 -.annotate 'line', 751 - new $P2066, "Undef" - .lex "$regex", $P2066 -.annotate 'line', 753 - new $P2067, "Undef" - .lex "$past", $P2067 -.annotate 'line', 742 - find_lex $P2069, "$key" - set $S2070, $P2069 - iseq $I2071, $S2070, "open" - unless $I2071, if_2068_end -.annotate 'line', 743 - - null $P0 - set_hll_global ['Regex';'P6Regex';'Actions'], '$REGEXNAME', $P0 - -.annotate 'line', 747 - get_global $P2072, "@BLOCK" - unless_null $P2072, vivify_602 - $P2072 = root_new ['parrot';'ResizablePMCArray'] - vivify_602: - set $P2073, $P2072[0] - unless_null $P2073, vivify_603 + .lex "$/", param_2072 +.annotate 'line', 750 new $P2073, "Undef" - vivify_603: - $P2073."symbol"(unicode:"$\x{a2}", "lexical" :named("scope")) -.annotate 'line', 748 - get_global $P2074, "@BLOCK" - unless_null $P2074, vivify_604 - $P2074 = root_new ['parrot';'ResizablePMCArray'] - vivify_604: - set $P2075, $P2074[0] - unless_null $P2075, vivify_605 - new $P2075, "Undef" - vivify_605: - $P2075."symbol"("$/", "lexical" :named("scope")) -.annotate 'line', 749 - new $P2076, "Exception" - set $P2076['type'], 57 - new $P2077, "Integer" - assign $P2077, 0 - setattribute $P2076, 'payload', $P2077 - throw $P2076 - if_2068_end: + .lex "$value", $P2073 + find_lex $P2076, "$/" + unless_null $P2076, vivify_614 + $P2076 = root_new ['parrot';'Hash'] + vivify_614: + set $P2077, $P2076["dec_number"] + unless_null $P2077, vivify_615 + new $P2077, "Undef" + vivify_615: + if $P2077, if_2075 + find_lex $P2081, "$/" + unless_null $P2081, vivify_616 + $P2081 = root_new ['parrot';'Hash'] + vivify_616: + set $P2082, $P2081["integer"] + unless_null $P2082, vivify_617 + new $P2082, "Undef" + vivify_617: + $P2083 = $P2082."ast"() + set $P2074, $P2083 + goto if_2075_end + if_2075: + find_lex $P2078, "$/" + unless_null $P2078, vivify_618 + $P2078 = root_new ['parrot';'Hash'] + vivify_618: + set $P2079, $P2078["dec_number"] + unless_null $P2079, vivify_619 + new $P2079, "Undef" + vivify_619: + $P2080 = $P2079."ast"() + set $P2074, $P2080 + if_2075_end: + store_lex "$value", $P2074 +.annotate 'line', 751 + find_lex $P2085, "$/" + unless_null $P2085, vivify_620 + $P2085 = root_new ['parrot';'Hash'] + vivify_620: + set $P2086, $P2085["sign"] + unless_null $P2086, vivify_621 + new $P2086, "Undef" + vivify_621: + set $S2087, $P2086 + iseq $I2088, $S2087, "-" + unless $I2088, if_2084_end + find_lex $P2089, "$value" + neg $P2090, $P2089 + store_lex "$value", $P2090 + if_2084_end: .annotate 'line', 752 - get_hll_global $P2078, ["Regex";"P6Regex";"Actions"], "buildsub" - find_lex $P2079, "$/" - unless_null $P2079, vivify_606 - $P2079 = root_new ['parrot';'Hash'] - vivify_606: - set $P2080, $P2079["p6regex"] - unless_null $P2080, vivify_607 - new $P2080, "Undef" - vivify_607: - $P2081 = $P2080."ast"() - get_global $P2082, "@BLOCK" - $P2083 = $P2082."shift"() - $P2084 = $P2078($P2081, $P2083) - store_lex "$regex", $P2084 -.annotate 'line', 754 - get_hll_global $P2085, ["PAST"], "Op" -.annotate 'line', 756 - get_hll_global $P2086, ["PAST"], "Var" - new $P2087, "ResizablePMCArray" - push $P2087, "Regex" - $P2088 = $P2086."new"("Regex" :named("name"), $P2087 :named("namespace"), "package" :named("scope")) - find_lex $P2089, "$regex" - $P2090 = $P2085."new"($P2088, $P2089, "callmethod" :named("pasttype"), "new" :named("name")) -.annotate 'line', 754 - store_lex "$past", $P2090 -.annotate 'line', 760 - find_lex $P2091, "$regex" - find_lex $P2092, "$past" - unless_null $P2092, vivify_608 - $P2092 = root_new ['parrot';'Hash'] - store_lex "$past", $P2092 - vivify_608: - set $P2092["sink"], $P2091 -.annotate 'line', 761 - find_lex $P2093, "$/" - find_lex $P2094, "$past" - $P2095 = $P2093."!make"($P2094) -.annotate 'line', 741 + find_lex $P2091, "$/" + get_hll_global $P2092, ["PAST"], "Val" + find_lex $P2093, "$value" + $P2094 = $P2092."new"($P2093 :named("value")) + $P2095 = $P2091."!make"($P2094) +.annotate 'line', 749 .return ($P2095) - control_2061: + control_2070: .local pmc exception .get_results (exception) getattribute $P2096, exception, "payload" @@ -23369,9 +23762,9 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "quote_escape:sym<$>" :subid("116_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "quote:sym" :subid("115_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_2100 -.annotate 'line', 764 +.annotate 'line', 755 new $P2099, 'ExceptionHandler' set_addr $P2099, control_2098 $P2099."handle_types"(57) @@ -23380,13 +23773,13 @@ NQP::Compiler - NQP compiler .lex "$/", param_2100 find_lex $P2101, "$/" find_lex $P2102, "$/" - unless_null $P2102, vivify_609 + unless_null $P2102, vivify_622 $P2102 = root_new ['parrot';'Hash'] - vivify_609: - set $P2103, $P2102["variable"] - unless_null $P2103, vivify_610 + vivify_622: + set $P2103, $P2102["quote_EXPR"] + unless_null $P2103, vivify_623 new $P2103, "Undef" - vivify_610: + vivify_623: $P2104 = $P2103."ast"() $P2105 = $P2101."!make"($P2104) .return ($P2105) @@ -23399,603 +23792,898 @@ NQP::Compiler - NQP compiler .namespace ["NQP";"Actions"] -.sub "quote_escape:sym<{ }>" :subid("117_1275511729.89077") :method :outer("11_1275511729.89077") +.sub "quote:sym" :subid("116_1275600017.58296") :method :outer("11_1275600017.58296") .param pmc param_2110 -.annotate 'line', 765 +.annotate 'line', 756 new $P2109, 'ExceptionHandler' set_addr $P2109, control_2108 $P2109."handle_types"(57) push_eh $P2109 .lex "self", self .lex "$/", param_2110 -.annotate 'line', 766 find_lex $P2111, "$/" - get_hll_global $P2112, ["PAST"], "Op" -.annotate 'line', 767 - find_lex $P2113, "$/" - unless_null $P2113, vivify_611 - $P2113 = root_new ['parrot';'Hash'] - vivify_611: - set $P2114, $P2113["block"] - unless_null $P2114, vivify_612 - new $P2114, "Undef" - vivify_612: - $P2115 = $P2114."ast"() - $P2116 = "block_immediate"($P2115) - find_lex $P2117, "$/" - $P2118 = $P2112."new"($P2116, "set S*" :named("pirop"), $P2117 :named("node")) -.annotate 'line', 766 - $P2119 = $P2111."!make"($P2118) -.annotate 'line', 765 - .return ($P2119) + find_lex $P2112, "$/" + unless_null $P2112, vivify_624 + $P2112 = root_new ['parrot';'Hash'] + vivify_624: + set $P2113, $P2112["quote_EXPR"] + unless_null $P2113, vivify_625 + new $P2113, "Undef" + vivify_625: + $P2114 = $P2113."ast"() + $P2115 = $P2111."!make"($P2114) + .return ($P2115) control_2108: .local pmc exception .get_results (exception) - getattribute $P2120, exception, "payload" - .return ($P2120) + getattribute $P2116, exception, "payload" + .return ($P2116) .end .namespace ["NQP";"Actions"] -.sub "quote_escape:sym" :subid("118_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2124 -.annotate 'line', 770 - new $P2123, 'ExceptionHandler' - set_addr $P2123, control_2122 - $P2123."handle_types"(57) - push_eh $P2123 +.sub "quote:sym" :subid("117_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2120 +.annotate 'line', 757 + new $P2119, 'ExceptionHandler' + set_addr $P2119, control_2118 + $P2119."handle_types"(57) + push_eh $P2119 .lex "self", self - .lex "$/", param_2124 - find_lex $P2125, "$/" - $P2126 = $P2125."!make"("\e") - .return ($P2126) - control_2122: + .lex "$/", param_2120 + find_lex $P2121, "$/" + find_lex $P2122, "$/" + unless_null $P2122, vivify_626 + $P2122 = root_new ['parrot';'Hash'] + vivify_626: + set $P2123, $P2122["quote_EXPR"] + unless_null $P2123, vivify_627 + new $P2123, "Undef" + vivify_627: + $P2124 = $P2123."ast"() + $P2125 = $P2121."!make"($P2124) + .return ($P2125) + control_2118: .local pmc exception .get_results (exception) - getattribute $P2127, exception, "payload" - .return ($P2127) + getattribute $P2126, exception, "payload" + .return ($P2126) .end .namespace ["NQP";"Actions"] -.sub "postfix:sym<.>" :subid("119_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2131 -.annotate 'line', 774 - new $P2130, 'ExceptionHandler' - set_addr $P2130, control_2129 - $P2130."handle_types"(57) - push_eh $P2130 +.sub "quote:sym" :subid("118_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2130 +.annotate 'line', 758 + new $P2129, 'ExceptionHandler' + set_addr $P2129, control_2128 + $P2129."handle_types"(57) + push_eh $P2129 .lex "self", self - .lex "$/", param_2131 + .lex "$/", param_2130 + find_lex $P2131, "$/" find_lex $P2132, "$/" - find_lex $P2133, "$/" - unless_null $P2133, vivify_613 - $P2133 = root_new ['parrot';'Hash'] - vivify_613: - set $P2134, $P2133["dotty"] - unless_null $P2134, vivify_614 - new $P2134, "Undef" - vivify_614: - $P2135 = $P2134."ast"() - $P2136 = $P2132."!make"($P2135) - .return ($P2136) - control_2129: + unless_null $P2132, vivify_628 + $P2132 = root_new ['parrot';'Hash'] + vivify_628: + set $P2133, $P2132["quote_EXPR"] + unless_null $P2133, vivify_629 + new $P2133, "Undef" + vivify_629: + $P2134 = $P2133."ast"() + $P2135 = $P2131."!make"($P2134) + .return ($P2135) + control_2128: .local pmc exception .get_results (exception) - getattribute $P2137, exception, "payload" - .return ($P2137) + getattribute $P2136, exception, "payload" + .return ($P2136) .end .namespace ["NQP";"Actions"] -.sub "postfix:sym<++>" :subid("120_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2141 -.annotate 'line', 776 - new $P2140, 'ExceptionHandler' - set_addr $P2140, control_2139 - $P2140."handle_types"(57) - push_eh $P2140 +.sub "quote:sym" :subid("119_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2140 +.annotate 'line', 759 + new $P2139, 'ExceptionHandler' + set_addr $P2139, control_2138 + $P2139."handle_types"(57) + push_eh $P2139 .lex "self", self - .lex "$/", param_2141 -.annotate 'line', 777 + .lex "$/", param_2140 + find_lex $P2141, "$/" find_lex $P2142, "$/" - get_hll_global $P2143, ["PAST"], "Op" + unless_null $P2142, vivify_630 + $P2142 = root_new ['parrot';'Hash'] + vivify_630: + set $P2143, $P2142["quote_EXPR"] + unless_null $P2143, vivify_631 + new $P2143, "Undef" + vivify_631: + $P2144 = $P2143."ast"() + $P2145 = $P2141."!make"($P2144) + .return ($P2145) + control_2138: + .local pmc exception + .get_results (exception) + getattribute $P2146, exception, "payload" + .return ($P2146) +.end + + +.namespace ["NQP";"Actions"] +.sub "quote:sym" :subid("120_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2150 +.annotate 'line', 760 + new $P2149, 'ExceptionHandler' + set_addr $P2149, control_2148 + $P2149."handle_types"(57) + push_eh $P2149 + .lex "self", self + .lex "$/", param_2150 +.annotate 'line', 761 + find_lex $P2151, "$/" + get_hll_global $P2152, ["PAST"], "Op" + find_lex $P2153, "$/" + unless_null $P2153, vivify_632 + $P2153 = root_new ['parrot';'Hash'] + vivify_632: + set $P2154, $P2153["quote_EXPR"] + unless_null $P2154, vivify_633 + new $P2154, "Undef" + vivify_633: + $P2155 = $P2154."ast"() + $P2156 = $P2155."value"() + find_lex $P2157, "$/" + $P2158 = $P2152."new"($P2156 :named("inline"), "inline" :named("pasttype"), $P2157 :named("node")) + $P2159 = $P2151."!make"($P2158) +.annotate 'line', 760 + .return ($P2159) + control_2148: + .local pmc exception + .get_results (exception) + getattribute $P2160, exception, "payload" + .return ($P2160) +.end + + +.namespace ["NQP";"Actions"] +.sub "quote:sym" :subid("121_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2164 + .param pmc param_2165 :optional + .param int has_param_2165 :opt_flag +.annotate 'line', 766 + new $P2163, 'ExceptionHandler' + set_addr $P2163, control_2162 + $P2163."handle_types"(57) + push_eh $P2163 + .lex "self", self + .lex "$/", param_2164 + if has_param_2165, optparam_634 + new $P2166, "Undef" + set param_2165, $P2166 + optparam_634: + .lex "$key", param_2165 +.annotate 'line', 776 + new $P2167, "Undef" + .lex "$regex", $P2167 .annotate 'line', 778 - new $P2144, "ResizablePMCArray" - push $P2144, " clone %r, %0" - push $P2144, " inc %0" - $P2145 = $P2143."new"("postfix:<++>" :named("name"), $P2144 :named("inline"), "inline" :named("pasttype")) + new $P2168, "Undef" + .lex "$past", $P2168 +.annotate 'line', 767 + find_lex $P2170, "$key" + set $S2171, $P2170 + iseq $I2172, $S2171, "open" + unless $I2172, if_2169_end +.annotate 'line', 768 + + null $P0 + set_hll_global ['Regex';'P6Regex';'Actions'], '$REGEXNAME', $P0 + +.annotate 'line', 772 + get_global $P2173, "@BLOCK" + unless_null $P2173, vivify_635 + $P2173 = root_new ['parrot';'ResizablePMCArray'] + vivify_635: + set $P2174, $P2173[0] + unless_null $P2174, vivify_636 + new $P2174, "Undef" + vivify_636: + $P2174."symbol"(unicode:"$\x{a2}", "lexical" :named("scope")) +.annotate 'line', 773 + get_global $P2175, "@BLOCK" + unless_null $P2175, vivify_637 + $P2175 = root_new ['parrot';'ResizablePMCArray'] + vivify_637: + set $P2176, $P2175[0] + unless_null $P2176, vivify_638 + new $P2176, "Undef" + vivify_638: + $P2176."symbol"("$/", "lexical" :named("scope")) +.annotate 'line', 774 + new $P2177, "Exception" + set $P2177['type'], 57 + new $P2178, "Integer" + assign $P2178, 0 + setattribute $P2177, 'payload', $P2178 + throw $P2177 + if_2169_end: .annotate 'line', 777 - $P2146 = $P2142."!make"($P2145) -.annotate 'line', 776 - .return ($P2146) - control_2139: + get_hll_global $P2179, ["Regex";"P6Regex";"Actions"], "buildsub" + find_lex $P2180, "$/" + unless_null $P2180, vivify_639 + $P2180 = root_new ['parrot';'Hash'] + vivify_639: + set $P2181, $P2180["p6regex"] + unless_null $P2181, vivify_640 + new $P2181, "Undef" + vivify_640: + $P2182 = $P2181."ast"() + get_global $P2183, "@BLOCK" + $P2184 = $P2183."shift"() + $P2185 = $P2179($P2182, $P2184) + store_lex "$regex", $P2185 +.annotate 'line', 779 + get_hll_global $P2186, ["PAST"], "Op" +.annotate 'line', 781 + get_hll_global $P2187, ["PAST"], "Var" + new $P2188, "ResizablePMCArray" + push $P2188, "Regex" + $P2189 = $P2187."new"("Regex" :named("name"), $P2188 :named("namespace"), "package" :named("scope")) + find_lex $P2190, "$regex" + $P2191 = $P2186."new"($P2189, $P2190, "callmethod" :named("pasttype"), "new" :named("name")) +.annotate 'line', 779 + store_lex "$past", $P2191 +.annotate 'line', 785 + find_lex $P2192, "$regex" + find_lex $P2193, "$past" + unless_null $P2193, vivify_641 + $P2193 = root_new ['parrot';'Hash'] + store_lex "$past", $P2193 + vivify_641: + set $P2193["sink"], $P2192 +.annotate 'line', 786 + find_lex $P2194, "$/" + find_lex $P2195, "$past" + $P2196 = $P2194."!make"($P2195) +.annotate 'line', 766 + .return ($P2196) + control_2162: .local pmc exception .get_results (exception) - getattribute $P2147, exception, "payload" - .return ($P2147) + getattribute $P2197, exception, "payload" + .return ($P2197) .end .namespace ["NQP";"Actions"] -.sub "postfix:sym<-->" :subid("121_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2151 -.annotate 'line', 782 - new $P2150, 'ExceptionHandler' - set_addr $P2150, control_2149 - $P2150."handle_types"(57) - push_eh $P2150 +.sub "quote_escape:sym<$>" :subid("122_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2201 +.annotate 'line', 789 + new $P2200, 'ExceptionHandler' + set_addr $P2200, control_2199 + $P2200."handle_types"(57) + push_eh $P2200 .lex "self", self - .lex "$/", param_2151 -.annotate 'line', 783 - find_lex $P2152, "$/" - get_hll_global $P2153, ["PAST"], "Op" -.annotate 'line', 784 - new $P2154, "ResizablePMCArray" - push $P2154, " clone %r, %0" - push $P2154, " dec %0" - $P2155 = $P2153."new"("postfix:<-->" :named("name"), $P2154 :named("inline"), "inline" :named("pasttype")) -.annotate 'line', 783 - $P2156 = $P2152."!make"($P2155) -.annotate 'line', 782 - .return ($P2156) - control_2149: + .lex "$/", param_2201 + find_lex $P2202, "$/" + find_lex $P2203, "$/" + unless_null $P2203, vivify_642 + $P2203 = root_new ['parrot';'Hash'] + vivify_642: + set $P2204, $P2203["variable"] + unless_null $P2204, vivify_643 + new $P2204, "Undef" + vivify_643: + $P2205 = $P2204."ast"() + $P2206 = $P2202."!make"($P2205) + .return ($P2206) + control_2199: .local pmc exception .get_results (exception) - getattribute $P2157, exception, "payload" - .return ($P2157) + getattribute $P2207, exception, "payload" + .return ($P2207) .end .namespace ["NQP";"Actions"] -.sub "prefix:sym" :subid("122_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2161 -.annotate 'line', 788 - new $P2160, 'ExceptionHandler' - set_addr $P2160, control_2159 - $P2160."handle_types"(57) - push_eh $P2160 +.sub "quote_escape:sym<{ }>" :subid("123_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2211 +.annotate 'line', 790 + new $P2210, 'ExceptionHandler' + set_addr $P2210, control_2209 + $P2210."handle_types"(57) + push_eh $P2210 .lex "self", self - .lex "$/", param_2161 -.annotate 'line', 789 - find_lex $P2162, "$/" - get_hll_global $P2163, ["PAST"], "Op" + .lex "$/", param_2211 +.annotate 'line', 791 + find_lex $P2212, "$/" + get_hll_global $P2213, ["PAST"], "Op" +.annotate 'line', 792 + find_lex $P2214, "$/" + unless_null $P2214, vivify_644 + $P2214 = root_new ['parrot';'Hash'] + vivify_644: + set $P2215, $P2214["block"] + unless_null $P2215, vivify_645 + new $P2215, "Undef" + vivify_645: + $P2216 = $P2215."ast"() + $P2217 = "block_immediate"($P2216) + find_lex $P2218, "$/" + $P2219 = $P2213."new"($P2217, "set S*" :named("pirop"), $P2218 :named("node")) +.annotate 'line', 791 + $P2220 = $P2212."!make"($P2219) .annotate 'line', 790 - get_hll_global $P2164, ["PAST"], "Var" - $P2165 = $P2164."new"("$/" :named("name"), "contextual" :named("scope")) - find_lex $P2166, "$/" - $P2167 = $P2163."new"($P2165, "callmethod" :named("pasttype"), "!make" :named("name"), $P2166 :named("node")) -.annotate 'line', 789 - $P2168 = $P2162."!make"($P2167) -.annotate 'line', 788 - .return ($P2168) - control_2159: + .return ($P2220) + control_2209: .local pmc exception .get_results (exception) - getattribute $P2169, exception, "payload" - .return ($P2169) + getattribute $P2221, exception, "payload" + .return ($P2221) .end .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("123_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2174 -.annotate 'line', 810 - new $P2173, 'ExceptionHandler' - set_addr $P2173, control_2172 - $P2173."handle_types"(57) - push_eh $P2173 +.sub "quote_escape:sym" :subid("124_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2225 +.annotate 'line', 795 + new $P2224, 'ExceptionHandler' + set_addr $P2224, control_2223 + $P2224."handle_types"(57) + push_eh $P2224 .lex "self", self - .lex "$/", param_2174 - find_lex $P2175, "$/" - $P2176 = "control"($P2175, ".CONTROL_LOOP_NEXT") - .return ($P2176) - control_2172: + .lex "$/", param_2225 + find_lex $P2226, "$/" + $P2227 = $P2226."!make"("\e") + .return ($P2227) + control_2223: .local pmc exception .get_results (exception) - getattribute $P2177, exception, "payload" - .return ($P2177) + getattribute $P2228, exception, "payload" + .return ($P2228) .end .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("124_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2181 -.annotate 'line', 811 - new $P2180, 'ExceptionHandler' - set_addr $P2180, control_2179 - $P2180."handle_types"(57) - push_eh $P2180 +.sub "postfix:sym<.>" :subid("125_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2232 +.annotate 'line', 799 + new $P2231, 'ExceptionHandler' + set_addr $P2231, control_2230 + $P2231."handle_types"(57) + push_eh $P2231 .lex "self", self - .lex "$/", param_2181 - find_lex $P2182, "$/" - $P2183 = "control"($P2182, ".CONTROL_LOOP_LAST") - .return ($P2183) - control_2179: + .lex "$/", param_2232 + find_lex $P2233, "$/" + find_lex $P2234, "$/" + unless_null $P2234, vivify_646 + $P2234 = root_new ['parrot';'Hash'] + vivify_646: + set $P2235, $P2234["dotty"] + unless_null $P2235, vivify_647 + new $P2235, "Undef" + vivify_647: + $P2236 = $P2235."ast"() + $P2237 = $P2233."!make"($P2236) + .return ($P2237) + control_2230: .local pmc exception .get_results (exception) - getattribute $P2184, exception, "payload" - .return ($P2184) + getattribute $P2238, exception, "payload" + .return ($P2238) .end .namespace ["NQP";"Actions"] -.sub "term:sym" :subid("125_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2188 -.annotate 'line', 812 - new $P2187, 'ExceptionHandler' - set_addr $P2187, control_2186 - $P2187."handle_types"(57) - push_eh $P2187 +.sub "postfix:sym<++>" :subid("126_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2242 +.annotate 'line', 801 + new $P2241, 'ExceptionHandler' + set_addr $P2241, control_2240 + $P2241."handle_types"(57) + push_eh $P2241 .lex "self", self - .lex "$/", param_2188 - find_lex $P2189, "$/" - $P2190 = "control"($P2189, ".CONTROL_LOOP_REDO") - .return ($P2190) - control_2186: + .lex "$/", param_2242 +.annotate 'line', 802 + find_lex $P2243, "$/" + get_hll_global $P2244, ["PAST"], "Op" +.annotate 'line', 803 + new $P2245, "ResizablePMCArray" + push $P2245, " clone %r, %0" + push $P2245, " inc %0" + $P2246 = $P2244."new"("postfix:<++>" :named("name"), $P2245 :named("inline"), "inline" :named("pasttype")) +.annotate 'line', 802 + $P2247 = $P2243."!make"($P2246) +.annotate 'line', 801 + .return ($P2247) + control_2240: .local pmc exception .get_results (exception) - getattribute $P2191, exception, "payload" - .return ($P2191) + getattribute $P2248, exception, "payload" + .return ($P2248) .end .namespace ["NQP";"Actions"] -.sub "infix:sym<~~>" :subid("126_1275511729.89077") :method :outer("11_1275511729.89077") - .param pmc param_2195 -.annotate 'line', 814 - new $P2194, 'ExceptionHandler' - set_addr $P2194, control_2193 - $P2194."handle_types"(57) - push_eh $P2194 +.sub "postfix:sym<-->" :subid("127_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2252 +.annotate 'line', 807 + new $P2251, 'ExceptionHandler' + set_addr $P2251, control_2250 + $P2251."handle_types"(57) + push_eh $P2251 + .lex "self", self + .lex "$/", param_2252 +.annotate 'line', 808 + find_lex $P2253, "$/" + get_hll_global $P2254, ["PAST"], "Op" +.annotate 'line', 809 + new $P2255, "ResizablePMCArray" + push $P2255, " clone %r, %0" + push $P2255, " dec %0" + $P2256 = $P2254."new"("postfix:<-->" :named("name"), $P2255 :named("inline"), "inline" :named("pasttype")) +.annotate 'line', 808 + $P2257 = $P2253."!make"($P2256) +.annotate 'line', 807 + .return ($P2257) + control_2250: + .local pmc exception + .get_results (exception) + getattribute $P2258, exception, "payload" + .return ($P2258) +.end + + +.namespace ["NQP";"Actions"] +.sub "prefix:sym" :subid("128_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2262 +.annotate 'line', 813 + new $P2261, 'ExceptionHandler' + set_addr $P2261, control_2260 + $P2261."handle_types"(57) + push_eh $P2261 .lex "self", self - .lex "$/", param_2195 + .lex "$/", param_2262 +.annotate 'line', 814 + find_lex $P2263, "$/" + get_hll_global $P2264, ["PAST"], "Op" .annotate 'line', 815 - find_lex $P2196, "$/" - get_hll_global $P2197, ["PAST"], "Op" - find_lex $P2198, "$/" - $P2199 = $P2197."new"("callmethod" :named("pasttype"), "ACCEPTS" :named("name"), $P2198 :named("node")) - $P2200 = $P2196."!make"($P2199) + get_hll_global $P2265, ["PAST"], "Var" + $P2266 = $P2265."new"("$/" :named("name"), "contextual" :named("scope")) + find_lex $P2267, "$/" + $P2268 = $P2264."new"($P2266, "callmethod" :named("pasttype"), "!make" :named("name"), $P2267 :named("node")) .annotate 'line', 814 - .return ($P2200) - control_2193: + $P2269 = $P2263."!make"($P2268) +.annotate 'line', 813 + .return ($P2269) + control_2260: + .local pmc exception + .get_results (exception) + getattribute $P2270, exception, "payload" + .return ($P2270) +.end + + +.namespace ["NQP";"Actions"] +.sub "term:sym" :subid("129_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2275 +.annotate 'line', 835 + new $P2274, 'ExceptionHandler' + set_addr $P2274, control_2273 + $P2274."handle_types"(57) + push_eh $P2274 + .lex "self", self + .lex "$/", param_2275 + find_lex $P2276, "$/" + $P2277 = "control"($P2276, ".CONTROL_LOOP_NEXT") + .return ($P2277) + control_2273: + .local pmc exception + .get_results (exception) + getattribute $P2278, exception, "payload" + .return ($P2278) +.end + + +.namespace ["NQP";"Actions"] +.sub "term:sym" :subid("130_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2282 +.annotate 'line', 836 + new $P2281, 'ExceptionHandler' + set_addr $P2281, control_2280 + $P2281."handle_types"(57) + push_eh $P2281 + .lex "self", self + .lex "$/", param_2282 + find_lex $P2283, "$/" + $P2284 = "control"($P2283, ".CONTROL_LOOP_LAST") + .return ($P2284) + control_2280: + .local pmc exception + .get_results (exception) + getattribute $P2285, exception, "payload" + .return ($P2285) +.end + + +.namespace ["NQP";"Actions"] +.sub "term:sym" :subid("131_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2289 +.annotate 'line', 837 + new $P2288, 'ExceptionHandler' + set_addr $P2288, control_2287 + $P2288."handle_types"(57) + push_eh $P2288 + .lex "self", self + .lex "$/", param_2289 + find_lex $P2290, "$/" + $P2291 = "control"($P2290, ".CONTROL_LOOP_REDO") + .return ($P2291) + control_2287: + .local pmc exception + .get_results (exception) + getattribute $P2292, exception, "payload" + .return ($P2292) +.end + + +.namespace ["NQP";"Actions"] +.sub "infix:sym<~~>" :subid("132_1275600017.58296") :method :outer("11_1275600017.58296") + .param pmc param_2296 +.annotate 'line', 839 + new $P2295, 'ExceptionHandler' + set_addr $P2295, control_2294 + $P2295."handle_types"(57) + push_eh $P2295 + .lex "self", self + .lex "$/", param_2296 +.annotate 'line', 840 + find_lex $P2297, "$/" + get_hll_global $P2298, ["PAST"], "Op" + find_lex $P2299, "$/" + $P2300 = $P2298."new"("callmethod" :named("pasttype"), "ACCEPTS" :named("name"), $P2299 :named("node")) + $P2301 = $P2297."!make"($P2300) +.annotate 'line', 839 + .return ($P2301) + control_2294: .local pmc exception .get_results (exception) - getattribute $P2201, exception, "payload" - .return ($P2201) + getattribute $P2302, exception, "payload" + .return ($P2302) .end .namespace ["NQP";"RegexActions"] -.sub "_block2202" :subid("127_1275511729.89077") :outer("11_1275511729.89077") -.annotate 'line', 819 - .const 'Sub' $P2287 = "134_1275511729.89077" - capture_lex $P2287 - .const 'Sub' $P2274 = "133_1275511729.89077" - capture_lex $P2274 - .const 'Sub' $P2257 = "132_1275511729.89077" - capture_lex $P2257 - .const 'Sub' $P2244 = "131_1275511729.89077" - capture_lex $P2244 - .const 'Sub' $P2231 = "130_1275511729.89077" - capture_lex $P2231 - .const 'Sub' $P2218 = "129_1275511729.89077" - capture_lex $P2218 - .const 'Sub' $P2204 = "128_1275511729.89077" - capture_lex $P2204 -.annotate 'line', 852 - .const 'Sub' $P2287 = "134_1275511729.89077" - newclosure $P2312, $P2287 -.annotate 'line', 819 - .return ($P2312) +.sub "_block2303" :subid("133_1275600017.58296") :outer("11_1275600017.58296") +.annotate 'line', 844 + .const 'Sub' $P2388 = "140_1275600017.58296" + capture_lex $P2388 + .const 'Sub' $P2375 = "139_1275600017.58296" + capture_lex $P2375 + .const 'Sub' $P2358 = "138_1275600017.58296" + capture_lex $P2358 + .const 'Sub' $P2345 = "137_1275600017.58296" + capture_lex $P2345 + .const 'Sub' $P2332 = "136_1275600017.58296" + capture_lex $P2332 + .const 'Sub' $P2319 = "135_1275600017.58296" + capture_lex $P2319 + .const 'Sub' $P2305 = "134_1275600017.58296" + capture_lex $P2305 +.annotate 'line', 877 + .const 'Sub' $P2388 = "140_1275600017.58296" + newclosure $P2413, $P2388 +.annotate 'line', 844 + .return ($P2413) .end .namespace ["NQP";"RegexActions"] -.sub "metachar:sym<:my>" :subid("128_1275511729.89077") :method :outer("127_1275511729.89077") - .param pmc param_2207 -.annotate 'line', 821 - new $P2206, 'ExceptionHandler' - set_addr $P2206, control_2205 - $P2206."handle_types"(57) - push_eh $P2206 +.sub "metachar:sym<:my>" :subid("134_1275600017.58296") :method :outer("133_1275600017.58296") + .param pmc param_2308 +.annotate 'line', 846 + new $P2307, 'ExceptionHandler' + set_addr $P2307, control_2306 + $P2307."handle_types"(57) + push_eh $P2307 .lex "self", self - .lex "$/", param_2207 -.annotate 'line', 822 - new $P2208, "Undef" - .lex "$past", $P2208 - find_lex $P2209, "$/" - unless_null $P2209, vivify_615 - $P2209 = root_new ['parrot';'Hash'] - vivify_615: - set $P2210, $P2209["statement"] - unless_null $P2210, vivify_616 - new $P2210, "Undef" - vivify_616: - $P2211 = $P2210."ast"() - store_lex "$past", $P2211 -.annotate 'line', 823 - find_lex $P2212, "$/" - get_hll_global $P2213, ["PAST"], "Regex" - find_lex $P2214, "$past" - $P2215 = $P2213."new"($P2214, "pastnode" :named("pasttype")) - $P2216 = $P2212."!make"($P2215) -.annotate 'line', 821 - .return ($P2216) - control_2205: + .lex "$/", param_2308 +.annotate 'line', 847 + new $P2309, "Undef" + .lex "$past", $P2309 + find_lex $P2310, "$/" + unless_null $P2310, vivify_648 + $P2310 = root_new ['parrot';'Hash'] + vivify_648: + set $P2311, $P2310["statement"] + unless_null $P2311, vivify_649 + new $P2311, "Undef" + vivify_649: + $P2312 = $P2311."ast"() + store_lex "$past", $P2312 +.annotate 'line', 848 + find_lex $P2313, "$/" + get_hll_global $P2314, ["PAST"], "Regex" + find_lex $P2315, "$past" + $P2316 = $P2314."new"($P2315, "pastnode" :named("pasttype")) + $P2317 = $P2313."!make"($P2316) +.annotate 'line', 846 + .return ($P2317) + control_2306: .local pmc exception .get_results (exception) - getattribute $P2217, exception, "payload" - .return ($P2217) + getattribute $P2318, exception, "payload" + .return ($P2318) .end .namespace ["NQP";"RegexActions"] -.sub "metachar:sym<{ }>" :subid("129_1275511729.89077") :method :outer("127_1275511729.89077") - .param pmc param_2221 -.annotate 'line', 826 - new $P2220, 'ExceptionHandler' - set_addr $P2220, control_2219 - $P2220."handle_types"(57) - push_eh $P2220 +.sub "metachar:sym<{ }>" :subid("135_1275600017.58296") :method :outer("133_1275600017.58296") + .param pmc param_2322 +.annotate 'line', 851 + new $P2321, 'ExceptionHandler' + set_addr $P2321, control_2320 + $P2321."handle_types"(57) + push_eh $P2321 .lex "self", self - .lex "$/", param_2221 -.annotate 'line', 827 - find_lex $P2222, "$/" - get_hll_global $P2223, ["PAST"], "Regex" - find_lex $P2224, "$/" - unless_null $P2224, vivify_617 - $P2224 = root_new ['parrot';'Hash'] - vivify_617: - set $P2225, $P2224["codeblock"] - unless_null $P2225, vivify_618 - new $P2225, "Undef" - vivify_618: - $P2226 = $P2225."ast"() - find_lex $P2227, "$/" - $P2228 = $P2223."new"($P2226, "pastnode" :named("pasttype"), $P2227 :named("node")) - $P2229 = $P2222."!make"($P2228) -.annotate 'line', 826 - .return ($P2229) - control_2219: + .lex "$/", param_2322 +.annotate 'line', 852 + find_lex $P2323, "$/" + get_hll_global $P2324, ["PAST"], "Regex" + find_lex $P2325, "$/" + unless_null $P2325, vivify_650 + $P2325 = root_new ['parrot';'Hash'] + vivify_650: + set $P2326, $P2325["codeblock"] + unless_null $P2326, vivify_651 + new $P2326, "Undef" + vivify_651: + $P2327 = $P2326."ast"() + find_lex $P2328, "$/" + $P2329 = $P2324."new"($P2327, "pastnode" :named("pasttype"), $P2328 :named("node")) + $P2330 = $P2323."!make"($P2329) +.annotate 'line', 851 + .return ($P2330) + control_2320: .local pmc exception .get_results (exception) - getattribute $P2230, exception, "payload" - .return ($P2230) + getattribute $P2331, exception, "payload" + .return ($P2331) .end .namespace ["NQP";"RegexActions"] -.sub "metachar:sym" :subid("130_1275511729.89077") :method :outer("127_1275511729.89077") - .param pmc param_2234 -.annotate 'line', 831 - new $P2233, 'ExceptionHandler' - set_addr $P2233, control_2232 - $P2233."handle_types"(57) - push_eh $P2233 +.sub "metachar:sym" :subid("136_1275600017.58296") :method :outer("133_1275600017.58296") + .param pmc param_2335 +.annotate 'line', 856 + new $P2334, 'ExceptionHandler' + set_addr $P2334, control_2333 + $P2334."handle_types"(57) + push_eh $P2334 .lex "self", self - .lex "$/", param_2234 -.annotate 'line', 832 - find_lex $P2235, "$/" - get_hll_global $P2236, ["PAST"], "Regex" - find_lex $P2237, "$/" - unless_null $P2237, vivify_619 - $P2237 = root_new ['parrot';'Hash'] - vivify_619: - set $P2238, $P2237["var"] - unless_null $P2238, vivify_620 - new $P2238, "Undef" - vivify_620: - $P2239 = $P2238."ast"() - find_lex $P2240, "$/" - $P2241 = $P2236."new"("!INTERPOLATE", $P2239, "subrule" :named("pasttype"), "method" :named("subtype"), $P2240 :named("node")) - $P2242 = $P2235."!make"($P2241) -.annotate 'line', 831 - .return ($P2242) - control_2232: + .lex "$/", param_2335 +.annotate 'line', 857 + find_lex $P2336, "$/" + get_hll_global $P2337, ["PAST"], "Regex" + find_lex $P2338, "$/" + unless_null $P2338, vivify_652 + $P2338 = root_new ['parrot';'Hash'] + vivify_652: + set $P2339, $P2338["var"] + unless_null $P2339, vivify_653 + new $P2339, "Undef" + vivify_653: + $P2340 = $P2339."ast"() + find_lex $P2341, "$/" + $P2342 = $P2337."new"("!INTERPOLATE", $P2340, "subrule" :named("pasttype"), "method" :named("subtype"), $P2341 :named("node")) + $P2343 = $P2336."!make"($P2342) +.annotate 'line', 856 + .return ($P2343) + control_2333: .local pmc exception .get_results (exception) - getattribute $P2243, exception, "payload" - .return ($P2243) + getattribute $P2344, exception, "payload" + .return ($P2344) .end .namespace ["NQP";"RegexActions"] -.sub "assertion:sym<{ }>" :subid("131_1275511729.89077") :method :outer("127_1275511729.89077") - .param pmc param_2247 -.annotate 'line', 836 - new $P2246, 'ExceptionHandler' - set_addr $P2246, control_2245 - $P2246."handle_types"(57) - push_eh $P2246 +.sub "assertion:sym<{ }>" :subid("137_1275600017.58296") :method :outer("133_1275600017.58296") + .param pmc param_2348 +.annotate 'line', 861 + new $P2347, 'ExceptionHandler' + set_addr $P2347, control_2346 + $P2347."handle_types"(57) + push_eh $P2347 .lex "self", self - .lex "$/", param_2247 -.annotate 'line', 837 - find_lex $P2248, "$/" - get_hll_global $P2249, ["PAST"], "Regex" - find_lex $P2250, "$/" - unless_null $P2250, vivify_621 - $P2250 = root_new ['parrot';'Hash'] - vivify_621: - set $P2251, $P2250["codeblock"] - unless_null $P2251, vivify_622 - new $P2251, "Undef" - vivify_622: - $P2252 = $P2251."ast"() - find_lex $P2253, "$/" - $P2254 = $P2249."new"("!INTERPOLATE_REGEX", $P2252, "subrule" :named("pasttype"), "method" :named("subtype"), $P2253 :named("node")) - $P2255 = $P2248."!make"($P2254) -.annotate 'line', 836 - .return ($P2255) - control_2245: + .lex "$/", param_2348 +.annotate 'line', 862 + find_lex $P2349, "$/" + get_hll_global $P2350, ["PAST"], "Regex" + find_lex $P2351, "$/" + unless_null $P2351, vivify_654 + $P2351 = root_new ['parrot';'Hash'] + vivify_654: + set $P2352, $P2351["codeblock"] + unless_null $P2352, vivify_655 + new $P2352, "Undef" + vivify_655: + $P2353 = $P2352."ast"() + find_lex $P2354, "$/" + $P2355 = $P2350."new"("!INTERPOLATE_REGEX", $P2353, "subrule" :named("pasttype"), "method" :named("subtype"), $P2354 :named("node")) + $P2356 = $P2349."!make"($P2355) +.annotate 'line', 861 + .return ($P2356) + control_2346: .local pmc exception .get_results (exception) - getattribute $P2256, exception, "payload" - .return ($P2256) + getattribute $P2357, exception, "payload" + .return ($P2357) .end .namespace ["NQP";"RegexActions"] -.sub "assertion:sym" :subid("132_1275511729.89077") :method :outer("127_1275511729.89077") - .param pmc param_2260 -.annotate 'line', 841 - new $P2259, 'ExceptionHandler' - set_addr $P2259, control_2258 - $P2259."handle_types"(57) - push_eh $P2259 +.sub "assertion:sym" :subid("138_1275600017.58296") :method :outer("133_1275600017.58296") + .param pmc param_2361 +.annotate 'line', 866 + new $P2360, 'ExceptionHandler' + set_addr $P2360, control_2359 + $P2360."handle_types"(57) + push_eh $P2360 .lex "self", self - .lex "$/", param_2260 -.annotate 'line', 842 - find_lex $P2261, "$/" - get_hll_global $P2262, ["PAST"], "Regex" - find_lex $P2263, "$/" - unless_null $P2263, vivify_623 - $P2263 = root_new ['parrot';'Hash'] - vivify_623: - set $P2264, $P2263["codeblock"] - unless_null $P2264, vivify_624 - new $P2264, "Undef" - vivify_624: - $P2265 = $P2264."ast"() -.annotate 'line', 843 - find_lex $P2266, "$/" - unless_null $P2266, vivify_625 - $P2266 = root_new ['parrot';'Hash'] - vivify_625: - set $P2267, $P2266["zw"] - unless_null $P2267, vivify_626 - new $P2267, "Undef" - vivify_626: - set $S2268, $P2267 - iseq $I2269, $S2268, "!" - find_lex $P2270, "$/" - $P2271 = $P2262."new"($P2265, "zerowidth" :named("subtype"), $I2269 :named("negate"), "pastnode" :named("pasttype"), $P2270 :named("node")) -.annotate 'line', 842 - $P2272 = $P2261."!make"($P2271) -.annotate 'line', 841 - .return ($P2272) - control_2258: + .lex "$/", param_2361 +.annotate 'line', 867 + find_lex $P2362, "$/" + get_hll_global $P2363, ["PAST"], "Regex" + find_lex $P2364, "$/" + unless_null $P2364, vivify_656 + $P2364 = root_new ['parrot';'Hash'] + vivify_656: + set $P2365, $P2364["codeblock"] + unless_null $P2365, vivify_657 + new $P2365, "Undef" + vivify_657: + $P2366 = $P2365."ast"() +.annotate 'line', 868 + find_lex $P2367, "$/" + unless_null $P2367, vivify_658 + $P2367 = root_new ['parrot';'Hash'] + vivify_658: + set $P2368, $P2367["zw"] + unless_null $P2368, vivify_659 + new $P2368, "Undef" + vivify_659: + set $S2369, $P2368 + iseq $I2370, $S2369, "!" + find_lex $P2371, "$/" + $P2372 = $P2363."new"($P2366, "zerowidth" :named("subtype"), $I2370 :named("negate"), "pastnode" :named("pasttype"), $P2371 :named("node")) +.annotate 'line', 867 + $P2373 = $P2362."!make"($P2372) +.annotate 'line', 866 + .return ($P2373) + control_2359: .local pmc exception .get_results (exception) - getattribute $P2273, exception, "payload" - .return ($P2273) + getattribute $P2374, exception, "payload" + .return ($P2374) .end .namespace ["NQP";"RegexActions"] -.sub "assertion:sym" :subid("133_1275511729.89077") :method :outer("127_1275511729.89077") - .param pmc param_2277 -.annotate 'line', 847 - new $P2276, 'ExceptionHandler' - set_addr $P2276, control_2275 - $P2276."handle_types"(57) - push_eh $P2276 +.sub "assertion:sym" :subid("139_1275600017.58296") :method :outer("133_1275600017.58296") + .param pmc param_2378 +.annotate 'line', 872 + new $P2377, 'ExceptionHandler' + set_addr $P2377, control_2376 + $P2377."handle_types"(57) + push_eh $P2377 .lex "self", self - .lex "$/", param_2277 -.annotate 'line', 848 - find_lex $P2278, "$/" - get_hll_global $P2279, ["PAST"], "Regex" - find_lex $P2280, "$/" - unless_null $P2280, vivify_627 - $P2280 = root_new ['parrot';'Hash'] - vivify_627: - set $P2281, $P2280["var"] - unless_null $P2281, vivify_628 - new $P2281, "Undef" - vivify_628: - $P2282 = $P2281."ast"() - find_lex $P2283, "$/" - $P2284 = $P2279."new"("!INTERPOLATE_REGEX", $P2282, "subrule" :named("pasttype"), "method" :named("subtype"), $P2283 :named("node")) - $P2285 = $P2278."!make"($P2284) -.annotate 'line', 847 - .return ($P2285) - control_2275: + .lex "$/", param_2378 +.annotate 'line', 873 + find_lex $P2379, "$/" + get_hll_global $P2380, ["PAST"], "Regex" + find_lex $P2381, "$/" + unless_null $P2381, vivify_660 + $P2381 = root_new ['parrot';'Hash'] + vivify_660: + set $P2382, $P2381["var"] + unless_null $P2382, vivify_661 + new $P2382, "Undef" + vivify_661: + $P2383 = $P2382."ast"() + find_lex $P2384, "$/" + $P2385 = $P2380."new"("!INTERPOLATE_REGEX", $P2383, "subrule" :named("pasttype"), "method" :named("subtype"), $P2384 :named("node")) + $P2386 = $P2379."!make"($P2385) +.annotate 'line', 872 + .return ($P2386) + control_2376: .local pmc exception .get_results (exception) - getattribute $P2286, exception, "payload" - .return ($P2286) + getattribute $P2387, exception, "payload" + .return ($P2387) .end .namespace ["NQP";"RegexActions"] -.sub "codeblock" :subid("134_1275511729.89077") :method :outer("127_1275511729.89077") - .param pmc param_2290 -.annotate 'line', 852 - new $P2289, 'ExceptionHandler' - set_addr $P2289, control_2288 - $P2289."handle_types"(57) - push_eh $P2289 +.sub "codeblock" :subid("140_1275600017.58296") :method :outer("133_1275600017.58296") + .param pmc param_2391 +.annotate 'line', 877 + new $P2390, 'ExceptionHandler' + set_addr $P2390, control_2389 + $P2390."handle_types"(57) + push_eh $P2390 .lex "self", self - .lex "$/", param_2290 -.annotate 'line', 853 - new $P2291, "Undef" - .lex "$block", $P2291 -.annotate 'line', 855 - new $P2292, "Undef" - .lex "$past", $P2292 -.annotate 'line', 853 - find_lex $P2293, "$/" - unless_null $P2293, vivify_629 - $P2293 = root_new ['parrot';'Hash'] - vivify_629: - set $P2294, $P2293["block"] - unless_null $P2294, vivify_630 - new $P2294, "Undef" - vivify_630: - $P2295 = $P2294."ast"() - store_lex "$block", $P2295 -.annotate 'line', 854 - find_lex $P2296, "$block" - $P2296."blocktype"("immediate") -.annotate 'line', 856 - get_hll_global $P2297, ["PAST"], "Stmts" -.annotate 'line', 857 - get_hll_global $P2298, ["PAST"], "Op" -.annotate 'line', 858 - get_hll_global $P2299, ["PAST"], "Var" - $P2300 = $P2299."new"("$/" :named("name")) -.annotate 'line', 859 - get_hll_global $P2301, ["PAST"], "Op" -.annotate 'line', 860 - get_hll_global $P2302, ["PAST"], "Var" - $P2303 = $P2302."new"(unicode:"$\x{a2}" :named("name")) - $P2304 = $P2301."new"($P2303, "MATCH" :named("name"), "callmethod" :named("pasttype")) -.annotate 'line', 859 - $P2305 = $P2298."new"($P2300, $P2304, "bind" :named("pasttype")) -.annotate 'line', 857 - find_lex $P2306, "$block" - $P2307 = $P2297."new"($P2305, $P2306) -.annotate 'line', 856 - store_lex "$past", $P2307 -.annotate 'line', 868 - find_lex $P2308, "$/" - find_lex $P2309, "$past" - $P2310 = $P2308."!make"($P2309) -.annotate 'line', 852 - .return ($P2310) - control_2288: + .lex "$/", param_2391 +.annotate 'line', 878 + new $P2392, "Undef" + .lex "$block", $P2392 +.annotate 'line', 880 + new $P2393, "Undef" + .lex "$past", $P2393 +.annotate 'line', 878 + find_lex $P2394, "$/" + unless_null $P2394, vivify_662 + $P2394 = root_new ['parrot';'Hash'] + vivify_662: + set $P2395, $P2394["block"] + unless_null $P2395, vivify_663 + new $P2395, "Undef" + vivify_663: + $P2396 = $P2395."ast"() + store_lex "$block", $P2396 +.annotate 'line', 879 + find_lex $P2397, "$block" + $P2397."blocktype"("immediate") +.annotate 'line', 881 + get_hll_global $P2398, ["PAST"], "Stmts" +.annotate 'line', 882 + get_hll_global $P2399, ["PAST"], "Op" +.annotate 'line', 883 + get_hll_global $P2400, ["PAST"], "Var" + $P2401 = $P2400."new"("$/" :named("name")) +.annotate 'line', 884 + get_hll_global $P2402, ["PAST"], "Op" +.annotate 'line', 885 + get_hll_global $P2403, ["PAST"], "Var" + $P2404 = $P2403."new"(unicode:"$\x{a2}" :named("name")) + $P2405 = $P2402."new"($P2404, "MATCH" :named("name"), "callmethod" :named("pasttype")) +.annotate 'line', 884 + $P2406 = $P2399."new"($P2401, $P2405, "bind" :named("pasttype")) +.annotate 'line', 882 + find_lex $P2407, "$block" + $P2408 = $P2398."new"($P2406, $P2407) +.annotate 'line', 881 + store_lex "$past", $P2408 +.annotate 'line', 893 + find_lex $P2409, "$/" + find_lex $P2410, "$past" + $P2411 = $P2409."!make"($P2410) +.annotate 'line', 877 + .return ($P2411) + control_2389: .local pmc exception .get_results (exception) - getattribute $P2311, exception, "payload" - .return ($P2311) + getattribute $P2412, exception, "payload" + .return ($P2412) .end .namespace ["NQP";"Actions"] -.sub "_block2314" :load :anon :subid("135_1275511729.89077") +.sub "_block2415" :load :anon :subid("141_1275600017.58296") .annotate 'line', 3 - .const 'Sub' $P2316 = "11_1275511729.89077" - $P2317 = $P2316() - .return ($P2317) + .const 'Sub' $P2417 = "11_1275600017.58296" + $P2418 = $P2417() + .return ($P2418) .end .namespace [] -.sub "_block2324" :load :anon :subid("137_1275511729.89077") +.sub "_block2425" :load :anon :subid("143_1275600017.58296") .annotate 'line', 1 - .const 'Sub' $P2326 = "10_1275511729.89077" - $P2327 = $P2326() - .return ($P2327) + .const 'Sub' $P2427 = "10_1275600017.58296" + $P2428 = $P2427() + .return ($P2428) .end ### .include 'src/cheats/nqp-builtins.pir' diff --git a/src/stage0/P6Regex-s0.pir b/src/stage0/P6Regex-s0.pir index 9bd0c81..b3c4d45 100644 --- a/src/stage0/P6Regex-s0.pir +++ b/src/stage0/P6Regex-s0.pir @@ -16,7 +16,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes ### .include 'gen/p6regex-grammar.pir' .namespace [] -.sub "_block11" :anon :subid("10_1275511689.56967") +.sub "_block11" :anon :subid("10_1275599996.35368") .annotate 'line', 0 get_hll_global $P14, ["Regex";"P6Regex";"Grammar"], "_block13" capture_lex $P14 @@ -30,151 +30,151 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .annotate 'line', 3 get_hll_global $P14, ["Regex";"P6Regex";"Grammar"], "_block13" capture_lex $P14 - $P583 = $P14() + $P587 = $P14() .annotate 'line', 1 - .return ($P583) - .const 'Sub' $P585 = "159_1275511689.56967" - .return ($P585) + .return ($P587) + .const 'Sub' $P589 = "159_1275599996.35368" + .return ($P589) .end .namespace [] -.sub "" :load :init :subid("post160") :outer("10_1275511689.56967") +.sub "" :load :init :subid("post160") :outer("10_1275599996.35368") .annotate 'line', 0 - .const 'Sub' $P12 = "10_1275511689.56967" + .const 'Sub' $P12 = "10_1275599996.35368" .local pmc block set block, $P12 - $P588 = get_root_global ["parrot"], "P6metaclass" - $P588."new_class"("Regex::P6Regex::Grammar", "HLL::Grammar" :named("parent")) -.end - - -.namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block13" :subid("11_1275511689.56967") :outer("10_1275511689.56967") -.annotate 'line', 3 - .const 'Sub' $P571 = "156_1275511689.56967" - capture_lex $P571 - .const 'Sub' $P563 = "154_1275511689.56967" - capture_lex $P563 - .const 'Sub' $P555 = "152_1275511689.56967" - capture_lex $P555 - .const 'Sub' $P534 = "147_1275511689.56967" - capture_lex $P534 - .const 'Sub' $P499 = "141_1275511689.56967" - capture_lex $P499 - .const 'Sub' $P487 = "138_1275511689.56967" - capture_lex $P487 - .const 'Sub' $P474 = "135_1275511689.56967" - capture_lex $P474 - .const 'Sub' $P468 = "133_1275511689.56967" - capture_lex $P468 - .const 'Sub' $P457 = "130_1275511689.56967" - capture_lex $P457 - .const 'Sub' $P446 = "127_1275511689.56967" - capture_lex $P446 - .const 'Sub' $P437 = "123_1275511689.56967" - capture_lex $P437 - .const 'Sub' $P431 = "121_1275511689.56967" - capture_lex $P431 - .const 'Sub' $P425 = "119_1275511689.56967" - capture_lex $P425 - .const 'Sub' $P419 = "117_1275511689.56967" - capture_lex $P419 - .const 'Sub' $P413 = "115_1275511689.56967" - capture_lex $P413 - .const 'Sub' $P405 = "113_1275511689.56967" - capture_lex $P405 - .const 'Sub' $P394 = "111_1275511689.56967" - capture_lex $P394 - .const 'Sub' $P383 = "109_1275511689.56967" - capture_lex $P383 - .const 'Sub' $P377 = "107_1275511689.56967" - capture_lex $P377 - .const 'Sub' $P371 = "105_1275511689.56967" - capture_lex $P371 - .const 'Sub' $P365 = "103_1275511689.56967" - capture_lex $P365 - .const 'Sub' $P359 = "101_1275511689.56967" - capture_lex $P359 - .const 'Sub' $P353 = "99_1275511689.56967" - capture_lex $P353 - .const 'Sub' $P347 = "97_1275511689.56967" - capture_lex $P347 - .const 'Sub' $P341 = "95_1275511689.56967" - capture_lex $P341 - .const 'Sub' $P335 = "93_1275511689.56967" - capture_lex $P335 - .const 'Sub' $P323 = "89_1275511689.56967" - capture_lex $P323 - .const 'Sub' $P311 = "87_1275511689.56967" - capture_lex $P311 - .const 'Sub' $P304 = "85_1275511689.56967" - capture_lex $P304 - .const 'Sub' $P287 = "83_1275511689.56967" - capture_lex $P287 - .const 'Sub' $P280 = "81_1275511689.56967" - capture_lex $P280 - .const 'Sub' $P274 = "79_1275511689.56967" - capture_lex $P274 - .const 'Sub' $P268 = "77_1275511689.56967" - capture_lex $P268 - .const 'Sub' $P261 = "75_1275511689.56967" - capture_lex $P261 - .const 'Sub' $P254 = "73_1275511689.56967" - capture_lex $P254 - .const 'Sub' $P247 = "71_1275511689.56967" - capture_lex $P247 - .const 'Sub' $P240 = "69_1275511689.56967" - capture_lex $P240 - .const 'Sub' $P234 = "67_1275511689.56967" - capture_lex $P234 - .const 'Sub' $P228 = "65_1275511689.56967" - capture_lex $P228 - .const 'Sub' $P222 = "63_1275511689.56967" - capture_lex $P222 - .const 'Sub' $P216 = "61_1275511689.56967" - capture_lex $P216 - .const 'Sub' $P210 = "59_1275511689.56967" - capture_lex $P210 - .const 'Sub' $P205 = "57_1275511689.56967" - capture_lex $P205 - .const 'Sub' $P200 = "55_1275511689.56967" - capture_lex $P200 - .const 'Sub' $P194 = "53_1275511689.56967" - capture_lex $P194 - .const 'Sub' $P188 = "51_1275511689.56967" - capture_lex $P188 - .const 'Sub' $P182 = "49_1275511689.56967" - capture_lex $P182 - .const 'Sub' $P166 = "44_1275511689.56967" - capture_lex $P166 - .const 'Sub' $P154 = "42_1275511689.56967" + $P592 = get_root_global ["parrot"], "P6metaclass" + $P592."new_class"("Regex::P6Regex::Grammar", "HLL::Grammar" :named("parent")) +.end + + +.namespace ["Regex";"P6Regex";"Grammar"] +.sub "_block13" :subid("11_1275599996.35368") :outer("10_1275599996.35368") +.annotate 'line', 3 + .const 'Sub' $P575 = "156_1275599996.35368" + capture_lex $P575 + .const 'Sub' $P567 = "154_1275599996.35368" + capture_lex $P567 + .const 'Sub' $P559 = "152_1275599996.35368" + capture_lex $P559 + .const 'Sub' $P538 = "147_1275599996.35368" + capture_lex $P538 + .const 'Sub' $P503 = "141_1275599996.35368" + capture_lex $P503 + .const 'Sub' $P491 = "138_1275599996.35368" + capture_lex $P491 + .const 'Sub' $P478 = "135_1275599996.35368" + capture_lex $P478 + .const 'Sub' $P472 = "133_1275599996.35368" + capture_lex $P472 + .const 'Sub' $P461 = "130_1275599996.35368" + capture_lex $P461 + .const 'Sub' $P450 = "127_1275599996.35368" + capture_lex $P450 + .const 'Sub' $P441 = "123_1275599996.35368" + capture_lex $P441 + .const 'Sub' $P435 = "121_1275599996.35368" + capture_lex $P435 + .const 'Sub' $P429 = "119_1275599996.35368" + capture_lex $P429 + .const 'Sub' $P423 = "117_1275599996.35368" + capture_lex $P423 + .const 'Sub' $P417 = "115_1275599996.35368" + capture_lex $P417 + .const 'Sub' $P409 = "113_1275599996.35368" + capture_lex $P409 + .const 'Sub' $P398 = "111_1275599996.35368" + capture_lex $P398 + .const 'Sub' $P387 = "109_1275599996.35368" + capture_lex $P387 + .const 'Sub' $P381 = "107_1275599996.35368" + capture_lex $P381 + .const 'Sub' $P375 = "105_1275599996.35368" + capture_lex $P375 + .const 'Sub' $P369 = "103_1275599996.35368" + capture_lex $P369 + .const 'Sub' $P363 = "101_1275599996.35368" + capture_lex $P363 + .const 'Sub' $P357 = "99_1275599996.35368" + capture_lex $P357 + .const 'Sub' $P351 = "97_1275599996.35368" + capture_lex $P351 + .const 'Sub' $P345 = "95_1275599996.35368" + capture_lex $P345 + .const 'Sub' $P339 = "93_1275599996.35368" + capture_lex $P339 + .const 'Sub' $P327 = "89_1275599996.35368" + capture_lex $P327 + .const 'Sub' $P315 = "87_1275599996.35368" + capture_lex $P315 + .const 'Sub' $P308 = "85_1275599996.35368" + capture_lex $P308 + .const 'Sub' $P291 = "83_1275599996.35368" + capture_lex $P291 + .const 'Sub' $P284 = "81_1275599996.35368" + capture_lex $P284 + .const 'Sub' $P278 = "79_1275599996.35368" + capture_lex $P278 + .const 'Sub' $P272 = "77_1275599996.35368" + capture_lex $P272 + .const 'Sub' $P265 = "75_1275599996.35368" + capture_lex $P265 + .const 'Sub' $P258 = "73_1275599996.35368" + capture_lex $P258 + .const 'Sub' $P251 = "71_1275599996.35368" + capture_lex $P251 + .const 'Sub' $P244 = "69_1275599996.35368" + capture_lex $P244 + .const 'Sub' $P238 = "67_1275599996.35368" + capture_lex $P238 + .const 'Sub' $P232 = "65_1275599996.35368" + capture_lex $P232 + .const 'Sub' $P226 = "63_1275599996.35368" + capture_lex $P226 + .const 'Sub' $P220 = "61_1275599996.35368" + capture_lex $P220 + .const 'Sub' $P214 = "59_1275599996.35368" + capture_lex $P214 + .const 'Sub' $P209 = "57_1275599996.35368" + capture_lex $P209 + .const 'Sub' $P204 = "55_1275599996.35368" + capture_lex $P204 + .const 'Sub' $P198 = "53_1275599996.35368" + capture_lex $P198 + .const 'Sub' $P192 = "51_1275599996.35368" + capture_lex $P192 + .const 'Sub' $P186 = "49_1275599996.35368" + capture_lex $P186 + .const 'Sub' $P170 = "44_1275599996.35368" + capture_lex $P170 + .const 'Sub' $P154 = "42_1275599996.35368" capture_lex $P154 - .const 'Sub' $P147 = "40_1275511689.56967" + .const 'Sub' $P147 = "40_1275599996.35368" capture_lex $P147 - .const 'Sub' $P140 = "38_1275511689.56967" + .const 'Sub' $P140 = "38_1275599996.35368" capture_lex $P140 - .const 'Sub' $P133 = "36_1275511689.56967" + .const 'Sub' $P133 = "36_1275599996.35368" capture_lex $P133 - .const 'Sub' $P114 = "31_1275511689.56967" + .const 'Sub' $P114 = "31_1275599996.35368" capture_lex $P114 - .const 'Sub' $P101 = "28_1275511689.56967" + .const 'Sub' $P101 = "28_1275599996.35368" capture_lex $P101 - .const 'Sub' $P94 = "26_1275511689.56967" + .const 'Sub' $P94 = "26_1275599996.35368" capture_lex $P94 - .const 'Sub' $P82 = "24_1275511689.56967" + .const 'Sub' $P82 = "24_1275599996.35368" capture_lex $P82 - .const 'Sub' $P75 = "22_1275511689.56967" + .const 'Sub' $P75 = "22_1275599996.35368" capture_lex $P75 - .const 'Sub' $P63 = "20_1275511689.56967" + .const 'Sub' $P63 = "20_1275599996.35368" capture_lex $P63 - .const 'Sub' $P56 = "18_1275511689.56967" + .const 'Sub' $P56 = "18_1275599996.35368" capture_lex $P56 - .const 'Sub' $P46 = "15_1275511689.56967" + .const 'Sub' $P46 = "15_1275599996.35368" capture_lex $P46 - .const 'Sub' $P38 = "13_1275511689.56967" + .const 'Sub' $P38 = "13_1275599996.35368" capture_lex $P38 - .const 'Sub' $P15 = "12_1275511689.56967" + .const 'Sub' $P15 = "12_1275599996.35368" capture_lex $P15 $P0 = find_dynamic_lex "$*CTXSAVE" if null $P0 goto ctxsave_done @@ -182,16 +182,16 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes unless $I0 goto ctxsave_done $P0."ctxsave"() ctxsave_done: - .const 'Sub' $P571 = "156_1275511689.56967" - capture_lex $P571 - .return ($P571) - .const 'Sub' $P580 = "158_1275511689.56967" - .return ($P580) + .const 'Sub' $P575 = "156_1275599996.35368" + capture_lex $P575 + .return ($P575) + .const 'Sub' $P584 = "158_1275599996.35368" + .return ($P584) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "obs" :subid("12_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "obs" :subid("12_1275599996.35368") :method :outer("11_1275599996.35368") .param pmc param_18 .param pmc param_19 .param pmc param_20 :optional @@ -239,7 +239,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "ws" :subid("13_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "ws" :subid("13_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 .local string rx39_tgt .local int rx39_pos @@ -322,7 +322,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__ws" :subid("14_1275511689.56967") :method +.sub "!PREFIX__ws" :subid("14_1275599996.35368") :method .annotate 'line', 3 new $P41, "ResizablePMCArray" push $P41, "" @@ -331,9 +331,9 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "normspace" :subid("15_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "normspace" :subid("15_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .const 'Sub' $P52 = "17_1275511689.56967" + .const 'Sub' $P52 = "17_1275599996.35368" capture_lex $P52 .local string rx47_tgt .local int rx47_pos @@ -368,7 +368,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .annotate 'line', 10 # rx subrule "before" subtype=zerowidth negate= rx47_cur."!cursor_pos"(rx47_pos) - .const 'Sub' $P52 = "17_1275511689.56967" + .const 'Sub' $P52 = "17_1275599996.35368" capture_lex $P52 $P10 = rx47_cur."before"($P52) unless $P10, rx47_fail @@ -396,7 +396,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__normspace" :subid("16_1275511689.56967") :method +.sub "!PREFIX__normspace" :subid("16_1275599996.35368") :method .annotate 'line', 3 new $P49, "ResizablePMCArray" push $P49, "" @@ -405,7 +405,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block51" :anon :subid("17_1275511689.56967") :method :outer("15_1275511689.56967") +.sub "_block51" :anon :subid("17_1275599996.35368") :method :outer("15_1275599996.35368") .annotate 'line', 10 .local string rx53_tgt .local int rx53_pos @@ -474,7 +474,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "arg" :subid("18_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "arg" :subid("18_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 .local string rx57_tgt .local int rx57_pos @@ -586,7 +586,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__arg" :subid("19_1275511689.56967") :method +.sub "!PREFIX__arg" :subid("19_1275599996.35368") :method .annotate 'line', 3 new $P59, "ResizablePMCArray" push $P59, "" @@ -597,7 +597,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "arglist" :subid("20_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "arglist" :subid("20_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 .local string rx64_tgt .local int rx64_pos @@ -704,7 +704,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__arglist" :subid("21_1275511689.56967") :method +.sub "!PREFIX__arglist" :subid("21_1275599996.35368") :method .annotate 'line', 3 new $P66, "ResizablePMCArray" push $P66, "" @@ -713,7 +713,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "TOP" :subid("22_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "TOP" :subid("22_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 .local string rx76_tgt .local int rx76_pos @@ -787,7 +787,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__TOP" :subid("23_1275511689.56967") :method +.sub "!PREFIX__TOP" :subid("23_1275599996.35368") :method .annotate 'line', 3 $P78 = self."!PREFIX__!subrule"("nibbler", "") new $P79, "ResizablePMCArray" @@ -797,7 +797,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "nibbler" :subid("24_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "nibbler" :subid("24_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 .local string rx83_tgt .local int rx83_pos @@ -966,7 +966,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__nibbler" :subid("25_1275511689.56967") :method +.sub "!PREFIX__nibbler" :subid("25_1275599996.35368") :method .annotate 'line', 3 new $P85, "ResizablePMCArray" push $P85, "" @@ -975,7 +975,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "termish" :subid("26_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "termish" :subid("26_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 .local string rx95_tgt .local int rx95_pos @@ -1044,7 +1044,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__termish" :subid("27_1275511689.56967") :method +.sub "!PREFIX__termish" :subid("27_1275599996.35368") :method .annotate 'line', 3 new $P97, "ResizablePMCArray" push $P97, "" @@ -1053,9 +1053,9 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "quantified_atom" :subid("28_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "quantified_atom" :subid("28_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .const 'Sub' $P110 = "30_1275511689.56967" + .const 'Sub' $P110 = "30_1275599996.35368" capture_lex $P110 .local string rx102_tgt .local int rx102_pos @@ -1119,7 +1119,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes alt108_1: # rx subrule "before" subtype=zerowidth negate= rx102_cur."!cursor_pos"(rx102_pos) - .const 'Sub' $P110 = "30_1275511689.56967" + .const 'Sub' $P110 = "30_1275599996.35368" capture_lex $P110 $P10 = rx102_cur."before"($P110) unless $P10, rx102_fail @@ -1157,7 +1157,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__quantified_atom" :subid("29_1275511689.56967") :method +.sub "!PREFIX__quantified_atom" :subid("29_1275599996.35368") :method .annotate 'line', 3 $P104 = self."!PREFIX__!subrule"("atom", "") new $P105, "ResizablePMCArray" @@ -1167,7 +1167,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block109" :anon :subid("30_1275511689.56967") :method :outer("28_1275511689.56967") +.sub "_block109" :anon :subid("30_1275599996.35368") :method :outer("28_1275599996.35368") .annotate 'line', 41 .local string rx111_tgt .local int rx111_pos @@ -1224,9 +1224,9 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "atom" :subid("31_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "atom" :subid("31_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .const 'Sub' $P125 = "33_1275511689.56967" + .const 'Sub' $P125 = "33_1275599996.35368" capture_lex $P125 .local string rx115_tgt .local int rx115_pos @@ -1287,7 +1287,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes rxquantg122_done: # rx subrule "before" subtype=zerowidth negate= rx115_cur."!cursor_pos"(rx115_pos) - .const 'Sub' $P125 = "33_1275511689.56967" + .const 'Sub' $P125 = "33_1275599996.35368" capture_lex $P125 $P10 = rx115_cur."before"($P125) unless $P10, rx115_fail @@ -1324,7 +1324,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__atom" :subid("32_1275511689.56967") :method +.sub "!PREFIX__atom" :subid("32_1275599996.35368") :method .annotate 'line', 3 $P117 = self."!PREFIX__!subrule"("metachar", "") new $P118, "ResizablePMCArray" @@ -1335,7 +1335,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block124" :anon :subid("33_1275511689.56967") :method :outer("31_1275511689.56967") +.sub "_block124" :anon :subid("33_1275599996.35368") :method :outer("31_1275599996.35368") .annotate 'line', 47 .local string rx126_tgt .local int rx126_pos @@ -1391,7 +1391,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "quantifier" :subid("34_1275511689.56967") :method +.sub "quantifier" :subid("34_1275599996.35368") :method .annotate 'line', 52 $P130 = self."!protoregex"("quantifier") .return ($P130) @@ -1399,7 +1399,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__quantifier" :subid("35_1275511689.56967") :method +.sub "!PREFIX__quantifier" :subid("35_1275599996.35368") :method .annotate 'line', 52 $P132 = self."!PREFIX__!protoregex"("quantifier") .return ($P132) @@ -1407,7 +1407,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "quantifier:sym<*>" :subid("36_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "quantifier:sym<*>" :subid("36_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 .local string rx134_tgt .local int rx134_pos @@ -1487,7 +1487,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__quantifier:sym<*>" :subid("37_1275511689.56967") :method +.sub "!PREFIX__quantifier:sym<*>" :subid("37_1275599996.35368") :method .annotate 'line', 3 $P136 = self."!PREFIX__!subrule"("backmod", "*") new $P137, "ResizablePMCArray" @@ -1497,7 +1497,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "quantifier:sym<+>" :subid("38_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "quantifier:sym<+>" :subid("38_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 .local string rx141_tgt .local int rx141_pos @@ -1577,7 +1577,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__quantifier:sym<+>" :subid("39_1275511689.56967") :method +.sub "!PREFIX__quantifier:sym<+>" :subid("39_1275599996.35368") :method .annotate 'line', 3 $P143 = self."!PREFIX__!subrule"("backmod", "+") new $P144, "ResizablePMCArray" @@ -1587,7 +1587,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "quantifier:sym" :subid("40_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "quantifier:sym" :subid("40_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 .local string rx148_tgt .local int rx148_pos @@ -1667,7 +1667,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__quantifier:sym" :subid("41_1275511689.56967") :method +.sub "!PREFIX__quantifier:sym" :subid("41_1275599996.35368") :method .annotate 'line', 3 $P150 = self."!PREFIX__!subrule"("backmod", "?") new $P151, "ResizablePMCArray" @@ -1677,7 +1677,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "quantifier:sym<**>" :subid("42_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "quantifier:sym<**>" :subid("42_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 .local string rx155_tgt .local int rx155_pos @@ -1687,7 +1687,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .local pmc rx155_cur (rx155_cur, rx155_pos, rx155_tgt) = self."!cursor_start"() rx155_cur."!cursor_debug"("START ", "quantifier:sym<**>") - rx155_cur."!cursor_caparray"("max") + rx155_cur."!cursor_caparray"("max", "normspace") .lex unicode:"$\x{a2}", rx155_cur .local pmc match .lex "$/", match @@ -1732,10 +1732,19 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes rxcap_159_fail: goto rx155_fail rxcap_159_done: - # rx charclass_q s r 0..-1 - sub $I10, rx155_pos, rx155_off - find_not_cclass $I11, 32, rx155_tgt, $I10, rx155_eos - add rx155_pos, rx155_off, $I11 + # rx rxquantr160 ** 0..1 + set_addr $I161, rxquantr160_done + rx155_cur."!mark_push"(0, rx155_pos, $I161) + rxquantr160_loop: + # rx subrule "normspace" subtype=capture negate= + rx155_cur."!cursor_pos"(rx155_pos) + $P10 = rx155_cur."normspace"() + unless $P10, rx155_fail + rx155_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("normspace") + rx155_pos = $P10."pos"() + (rx155_rep) = rx155_cur."!mark_commit"($I161) + rxquantr160_done: # rx subrule "backmod" subtype=capture negate= rx155_cur."!cursor_pos"(rx155_pos) $P10 = rx155_cur."backmod"() @@ -1743,17 +1752,26 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes rx155_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("backmod") rx155_pos = $P10."pos"() - # rx charclass_q s r 0..-1 - sub $I10, rx155_pos, rx155_off - find_not_cclass $I11, 32, rx155_tgt, $I10, rx155_eos - add rx155_pos, rx155_off, $I11 - alt160_0: + # rx rxquantr162 ** 0..1 + set_addr $I163, rxquantr162_done + rx155_cur."!mark_push"(0, rx155_pos, $I163) + rxquantr162_loop: + # rx subrule "normspace" subtype=capture negate= + rx155_cur."!cursor_pos"(rx155_pos) + $P10 = rx155_cur."normspace"() + unless $P10, rx155_fail + rx155_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("normspace") + rx155_pos = $P10."pos"() + (rx155_rep) = rx155_cur."!mark_commit"($I163) + rxquantr162_done: + alt164_0: .annotate 'line', 58 - set_addr $I10, alt160_1 + set_addr $I10, alt164_1 rx155_cur."!mark_push"(0, rx155_pos, $I10) .annotate 'line', 59 # rx subcapture "min" - set_addr $I10, rxcap_161_fail + set_addr $I10, rxcap_165_fail rx155_cur."!mark_push"(0, rx155_pos, $I10) # rx charclass_q d r 1..-1 sub $I10, rx155_pos, rx155_off @@ -1761,22 +1779,22 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes add $I12, $I10, 1 lt $I11, $I12, rx155_fail add rx155_pos, rx155_off, $I11 - set_addr $I10, rxcap_161_fail + set_addr $I10, rxcap_165_fail ($I12, $I11) = rx155_cur."!mark_peek"($I10) rx155_cur."!cursor_pos"($I11) ($P10) = rx155_cur."!cursor_start"() $P10."!cursor_pass"(rx155_pos, "") rx155_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("min") - goto rxcap_161_done - rxcap_161_fail: + goto rxcap_165_done + rxcap_165_fail: goto rx155_fail - rxcap_161_done: + rxcap_165_done: .annotate 'line', 66 - # rx rxquantr162 ** 0..1 - set_addr $I165, rxquantr162_done - rx155_cur."!mark_push"(0, rx155_pos, $I165) - rxquantr162_loop: + # rx rxquantr166 ** 0..1 + set_addr $I169, rxquantr166_done + rx155_cur."!mark_push"(0, rx155_pos, $I169) + rxquantr166_loop: .annotate 'line', 60 # rx literal ".." add $I11, rx155_pos, 2 @@ -1787,10 +1805,10 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes add rx155_pos, 2 .annotate 'line', 61 # rx subcapture "max" - set_addr $I10, rxcap_164_fail + set_addr $I10, rxcap_168_fail rx155_cur."!mark_push"(0, rx155_pos, $I10) - alt163_0: - set_addr $I10, alt163_1 + alt167_0: + set_addr $I10, alt167_1 rx155_cur."!mark_push"(0, rx155_pos, $I10) .annotate 'line', 62 # rx charclass_q d r 1..-1 @@ -1799,9 +1817,9 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes add $I12, $I10, 1 lt $I11, $I12, rx155_fail add rx155_pos, rx155_off, $I11 - goto alt163_end - alt163_1: - set_addr $I10, alt163_2 + goto alt167_end + alt167_1: + set_addr $I10, alt167_2 rx155_cur."!mark_push"(0, rx155_pos, $I10) .annotate 'line', 63 # rx literal "*" @@ -1811,33 +1829,33 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes substr $S10, rx155_tgt, $I11, 1 ne $S10, "*", rx155_fail add rx155_pos, 1 - goto alt163_end - alt163_2: + goto alt167_end + alt167_2: .annotate 'line', 64 # rx subrule "panic" subtype=method negate= rx155_cur."!cursor_pos"(rx155_pos) $P10 = rx155_cur."panic"("Only integers or '*' allowed as range quantifier endpoint") unless $P10, rx155_fail rx155_pos = $P10."pos"() - alt163_end: + alt167_end: .annotate 'line', 61 - set_addr $I10, rxcap_164_fail + set_addr $I10, rxcap_168_fail ($I12, $I11) = rx155_cur."!mark_peek"($I10) rx155_cur."!cursor_pos"($I11) ($P10) = rx155_cur."!cursor_start"() $P10."!cursor_pass"(rx155_pos, "") rx155_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("max") - goto rxcap_164_done - rxcap_164_fail: + goto rxcap_168_done + rxcap_168_fail: goto rx155_fail - rxcap_164_done: + rxcap_168_done: .annotate 'line', 66 - (rx155_rep) = rx155_cur."!mark_commit"($I165) - rxquantr162_done: + (rx155_rep) = rx155_cur."!mark_commit"($I169) + rxquantr166_done: .annotate 'line', 59 - goto alt160_end - alt160_1: + goto alt164_end + alt164_1: .annotate 'line', 67 # rx subrule "quantified_atom" subtype=capture negate= rx155_cur."!cursor_pos"(rx155_pos) @@ -1846,7 +1864,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes rx155_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quantified_atom") rx155_pos = $P10."pos"() - alt160_end: + alt164_end: .annotate 'line', 56 # rx pass rx155_cur."!cursor_pass"(rx155_pos, "quantifier:sym<**>") @@ -1867,7 +1885,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__quantifier:sym<**>" :subid("43_1275511689.56967") :method +.sub "!PREFIX__quantifier:sym<**>" :subid("43_1275599996.35368") :method .annotate 'line', 3 new $P157, "ResizablePMCArray" push $P157, "**" @@ -1876,4167 +1894,4108 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backmod" :subid("44_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backmod" :subid("44_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .const 'Sub' $P175 = "46_1275511689.56967" - capture_lex $P175 - .local string rx167_tgt - .local int rx167_pos - .local int rx167_off - .local int rx167_eos - .local int rx167_rep - .local pmc rx167_cur - (rx167_cur, rx167_pos, rx167_tgt) = self."!cursor_start"() - rx167_cur."!cursor_debug"("START ", "backmod") - .lex unicode:"$\x{a2}", rx167_cur + .const 'Sub' $P179 = "46_1275599996.35368" + capture_lex $P179 + .local string rx171_tgt + .local int rx171_pos + .local int rx171_off + .local int rx171_eos + .local int rx171_rep + .local pmc rx171_cur + (rx171_cur, rx171_pos, rx171_tgt) = self."!cursor_start"() + rx171_cur."!cursor_debug"("START ", "backmod") + .lex unicode:"$\x{a2}", rx171_cur .local pmc match .lex "$/", match - length rx167_eos, rx167_tgt - gt rx167_pos, rx167_eos, rx167_done - set rx167_off, 0 - lt rx167_pos, 2, rx167_start - sub rx167_off, rx167_pos, 1 - substr rx167_tgt, rx167_tgt, rx167_off - rx167_start: + length rx171_eos, rx171_tgt + gt rx171_pos, rx171_eos, rx171_done + set rx171_off, 0 + lt rx171_pos, 2, rx171_start + sub rx171_off, rx171_pos, 1 + substr rx171_tgt, rx171_tgt, rx171_off + rx171_start: $I10 = self.'from'() - ne $I10, -1, rxscan170_done - goto rxscan170_scan - rxscan170_loop: - ($P10) = rx167_cur."from"() + ne $I10, -1, rxscan174_done + goto rxscan174_scan + rxscan174_loop: + ($P10) = rx171_cur."from"() inc $P10 - set rx167_pos, $P10 - ge rx167_pos, rx167_eos, rxscan170_done - rxscan170_scan: - set_addr $I10, rxscan170_loop - rx167_cur."!mark_push"(0, rx167_pos, $I10) - rxscan170_done: + set rx171_pos, $P10 + ge rx171_pos, rx171_eos, rxscan174_done + rxscan174_scan: + set_addr $I10, rxscan174_loop + rx171_cur."!mark_push"(0, rx171_pos, $I10) + rxscan174_done: .annotate 'line', 71 - # rx rxquantr171 ** 0..1 - set_addr $I172, rxquantr171_done - rx167_cur."!mark_push"(0, rx167_pos, $I172) - rxquantr171_loop: + # rx rxquantr175 ** 0..1 + set_addr $I176, rxquantr175_done + rx171_cur."!mark_push"(0, rx171_pos, $I176) + rxquantr175_loop: # rx literal ":" - add $I11, rx167_pos, 1 - gt $I11, rx167_eos, rx167_fail - sub $I11, rx167_pos, rx167_off - substr $S10, rx167_tgt, $I11, 1 - ne $S10, ":", rx167_fail - add rx167_pos, 1 - (rx167_rep) = rx167_cur."!mark_commit"($I172) - rxquantr171_done: - alt173_0: - set_addr $I10, alt173_1 - rx167_cur."!mark_push"(0, rx167_pos, $I10) + add $I11, rx171_pos, 1 + gt $I11, rx171_eos, rx171_fail + sub $I11, rx171_pos, rx171_off + substr $S10, rx171_tgt, $I11, 1 + ne $S10, ":", rx171_fail + add rx171_pos, 1 + (rx171_rep) = rx171_cur."!mark_commit"($I176) + rxquantr175_done: + alt177_0: + set_addr $I10, alt177_1 + rx171_cur."!mark_push"(0, rx171_pos, $I10) # rx literal "?" - add $I11, rx167_pos, 1 - gt $I11, rx167_eos, rx167_fail - sub $I11, rx167_pos, rx167_off - substr $S10, rx167_tgt, $I11, 1 - ne $S10, "?", rx167_fail - add rx167_pos, 1 - goto alt173_end - alt173_1: - set_addr $I10, alt173_2 - rx167_cur."!mark_push"(0, rx167_pos, $I10) + add $I11, rx171_pos, 1 + gt $I11, rx171_eos, rx171_fail + sub $I11, rx171_pos, rx171_off + substr $S10, rx171_tgt, $I11, 1 + ne $S10, "?", rx171_fail + add rx171_pos, 1 + goto alt177_end + alt177_1: + set_addr $I10, alt177_2 + rx171_cur."!mark_push"(0, rx171_pos, $I10) # rx literal "!" - add $I11, rx167_pos, 1 - gt $I11, rx167_eos, rx167_fail - sub $I11, rx167_pos, rx167_off - substr $S10, rx167_tgt, $I11, 1 - ne $S10, "!", rx167_fail - add rx167_pos, 1 - goto alt173_end - alt173_2: + add $I11, rx171_pos, 1 + gt $I11, rx171_eos, rx171_fail + sub $I11, rx171_pos, rx171_off + substr $S10, rx171_tgt, $I11, 1 + ne $S10, "!", rx171_fail + add rx171_pos, 1 + goto alt177_end + alt177_2: # rx subrule "before" subtype=zerowidth negate=1 - rx167_cur."!cursor_pos"(rx167_pos) - .const 'Sub' $P175 = "46_1275511689.56967" - capture_lex $P175 - $P10 = rx167_cur."before"($P175) - if $P10, rx167_fail - alt173_end: + rx171_cur."!cursor_pos"(rx171_pos) + .const 'Sub' $P179 = "46_1275599996.35368" + capture_lex $P179 + $P10 = rx171_cur."before"($P179) + if $P10, rx171_fail + alt177_end: # rx pass - rx167_cur."!cursor_pass"(rx167_pos, "backmod") - rx167_cur."!cursor_debug"("PASS ", "backmod", " at pos=", rx167_pos) - .return (rx167_cur) - rx167_fail: -.annotate 'line', 3 - (rx167_rep, rx167_pos, $I10, $P10) = rx167_cur."!mark_fail"(0) - lt rx167_pos, -1, rx167_done - eq rx167_pos, -1, rx167_fail + rx171_cur."!cursor_pass"(rx171_pos, "backmod") + rx171_cur."!cursor_debug"("PASS ", "backmod", " at pos=", rx171_pos) + .return (rx171_cur) + rx171_fail: +.annotate 'line', 3 + (rx171_rep, rx171_pos, $I10, $P10) = rx171_cur."!mark_fail"(0) + lt rx171_pos, -1, rx171_done + eq rx171_pos, -1, rx171_fail jump $I10 - rx167_done: - rx167_cur."!cursor_fail"() - rx167_cur."!cursor_debug"("FAIL ", "backmod") - .return (rx167_cur) + rx171_done: + rx171_cur."!cursor_fail"() + rx171_cur."!cursor_debug"("FAIL ", "backmod") + .return (rx171_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backmod" :subid("45_1275511689.56967") :method +.sub "!PREFIX__backmod" :subid("45_1275599996.35368") :method .annotate 'line', 3 - new $P169, "ResizablePMCArray" - push $P169, "" - .return ($P169) + new $P173, "ResizablePMCArray" + push $P173, "" + .return ($P173) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block174" :anon :subid("46_1275511689.56967") :method :outer("44_1275511689.56967") +.sub "_block178" :anon :subid("46_1275599996.35368") :method :outer("44_1275599996.35368") .annotate 'line', 71 - .local string rx176_tgt - .local int rx176_pos - .local int rx176_off - .local int rx176_eos - .local int rx176_rep - .local pmc rx176_cur - (rx176_cur, rx176_pos, rx176_tgt) = self."!cursor_start"() - rx176_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx176_cur + .local string rx180_tgt + .local int rx180_pos + .local int rx180_off + .local int rx180_eos + .local int rx180_rep + .local pmc rx180_cur + (rx180_cur, rx180_pos, rx180_tgt) = self."!cursor_start"() + rx180_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx180_cur .local pmc match .lex "$/", match - length rx176_eos, rx176_tgt - gt rx176_pos, rx176_eos, rx176_done - set rx176_off, 0 - lt rx176_pos, 2, rx176_start - sub rx176_off, rx176_pos, 1 - substr rx176_tgt, rx176_tgt, rx176_off - rx176_start: + length rx180_eos, rx180_tgt + gt rx180_pos, rx180_eos, rx180_done + set rx180_off, 0 + lt rx180_pos, 2, rx180_start + sub rx180_off, rx180_pos, 1 + substr rx180_tgt, rx180_tgt, rx180_off + rx180_start: $I10 = self.'from'() - ne $I10, -1, rxscan177_done - goto rxscan177_scan - rxscan177_loop: - ($P10) = rx176_cur."from"() + ne $I10, -1, rxscan181_done + goto rxscan181_scan + rxscan181_loop: + ($P10) = rx180_cur."from"() inc $P10 - set rx176_pos, $P10 - ge rx176_pos, rx176_eos, rxscan177_done - rxscan177_scan: - set_addr $I10, rxscan177_loop - rx176_cur."!mark_push"(0, rx176_pos, $I10) - rxscan177_done: + set rx180_pos, $P10 + ge rx180_pos, rx180_eos, rxscan181_done + rxscan181_scan: + set_addr $I10, rxscan181_loop + rx180_cur."!mark_push"(0, rx180_pos, $I10) + rxscan181_done: # rx literal ":" - add $I11, rx176_pos, 1 - gt $I11, rx176_eos, rx176_fail - sub $I11, rx176_pos, rx176_off - substr $S10, rx176_tgt, $I11, 1 - ne $S10, ":", rx176_fail - add rx176_pos, 1 + add $I11, rx180_pos, 1 + gt $I11, rx180_eos, rx180_fail + sub $I11, rx180_pos, rx180_off + substr $S10, rx180_tgt, $I11, 1 + ne $S10, ":", rx180_fail + add rx180_pos, 1 # rx pass - rx176_cur."!cursor_pass"(rx176_pos, "") - rx176_cur."!cursor_debug"("PASS ", "", " at pos=", rx176_pos) - .return (rx176_cur) - rx176_fail: - (rx176_rep, rx176_pos, $I10, $P10) = rx176_cur."!mark_fail"(0) - lt rx176_pos, -1, rx176_done - eq rx176_pos, -1, rx176_fail + rx180_cur."!cursor_pass"(rx180_pos, "") + rx180_cur."!cursor_debug"("PASS ", "", " at pos=", rx180_pos) + .return (rx180_cur) + rx180_fail: + (rx180_rep, rx180_pos, $I10, $P10) = rx180_cur."!mark_fail"(0) + lt rx180_pos, -1, rx180_done + eq rx180_pos, -1, rx180_fail jump $I10 - rx176_done: - rx176_cur."!cursor_fail"() - rx176_cur."!cursor_debug"("FAIL ", "") - .return (rx176_cur) + rx180_done: + rx180_cur."!cursor_fail"() + rx180_cur."!cursor_debug"("FAIL ", "") + .return (rx180_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar" :subid("47_1275511689.56967") :method +.sub "metachar" :subid("47_1275599996.35368") :method .annotate 'line', 73 - $P179 = self."!protoregex"("metachar") - .return ($P179) + $P183 = self."!protoregex"("metachar") + .return ($P183) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar" :subid("48_1275511689.56967") :method +.sub "!PREFIX__metachar" :subid("48_1275599996.35368") :method .annotate 'line', 73 - $P181 = self."!PREFIX__!protoregex"("metachar") - .return ($P181) + $P185 = self."!PREFIX__!protoregex"("metachar") + .return ($P185) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym" :subid("49_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym" :subid("49_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx183_tgt - .local int rx183_pos - .local int rx183_off - .local int rx183_eos - .local int rx183_rep - .local pmc rx183_cur - (rx183_cur, rx183_pos, rx183_tgt) = self."!cursor_start"() - rx183_cur."!cursor_debug"("START ", "metachar:sym") - .lex unicode:"$\x{a2}", rx183_cur + .local string rx187_tgt + .local int rx187_pos + .local int rx187_off + .local int rx187_eos + .local int rx187_rep + .local pmc rx187_cur + (rx187_cur, rx187_pos, rx187_tgt) = self."!cursor_start"() + rx187_cur."!cursor_debug"("START ", "metachar:sym") + .lex unicode:"$\x{a2}", rx187_cur .local pmc match .lex "$/", match - length rx183_eos, rx183_tgt - gt rx183_pos, rx183_eos, rx183_done - set rx183_off, 0 - lt rx183_pos, 2, rx183_start - sub rx183_off, rx183_pos, 1 - substr rx183_tgt, rx183_tgt, rx183_off - rx183_start: + length rx187_eos, rx187_tgt + gt rx187_pos, rx187_eos, rx187_done + set rx187_off, 0 + lt rx187_pos, 2, rx187_start + sub rx187_off, rx187_pos, 1 + substr rx187_tgt, rx187_tgt, rx187_off + rx187_start: $I10 = self.'from'() - ne $I10, -1, rxscan187_done - goto rxscan187_scan - rxscan187_loop: - ($P10) = rx183_cur."from"() + ne $I10, -1, rxscan191_done + goto rxscan191_scan + rxscan191_loop: + ($P10) = rx187_cur."from"() inc $P10 - set rx183_pos, $P10 - ge rx183_pos, rx183_eos, rxscan187_done - rxscan187_scan: - set_addr $I10, rxscan187_loop - rx183_cur."!mark_push"(0, rx183_pos, $I10) - rxscan187_done: + set rx187_pos, $P10 + ge rx187_pos, rx187_eos, rxscan191_done + rxscan191_scan: + set_addr $I10, rxscan191_loop + rx187_cur."!mark_push"(0, rx187_pos, $I10) + rxscan191_done: .annotate 'line', 74 # rx subrule "normspace" subtype=method negate= - rx183_cur."!cursor_pos"(rx183_pos) - $P10 = rx183_cur."normspace"() - unless $P10, rx183_fail - rx183_pos = $P10."pos"() + rx187_cur."!cursor_pos"(rx187_pos) + $P10 = rx187_cur."normspace"() + unless $P10, rx187_fail + rx187_pos = $P10."pos"() # rx pass - rx183_cur."!cursor_pass"(rx183_pos, "metachar:sym") - rx183_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx183_pos) - .return (rx183_cur) - rx183_fail: -.annotate 'line', 3 - (rx183_rep, rx183_pos, $I10, $P10) = rx183_cur."!mark_fail"(0) - lt rx183_pos, -1, rx183_done - eq rx183_pos, -1, rx183_fail + rx187_cur."!cursor_pass"(rx187_pos, "metachar:sym") + rx187_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx187_pos) + .return (rx187_cur) + rx187_fail: +.annotate 'line', 3 + (rx187_rep, rx187_pos, $I10, $P10) = rx187_cur."!mark_fail"(0) + lt rx187_pos, -1, rx187_done + eq rx187_pos, -1, rx187_fail jump $I10 - rx183_done: - rx183_cur."!cursor_fail"() - rx183_cur."!cursor_debug"("FAIL ", "metachar:sym") - .return (rx183_cur) + rx187_done: + rx187_cur."!cursor_fail"() + rx187_cur."!cursor_debug"("FAIL ", "metachar:sym") + .return (rx187_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym" :subid("50_1275511689.56967") :method +.sub "!PREFIX__metachar:sym" :subid("50_1275599996.35368") :method .annotate 'line', 3 - $P185 = self."!PREFIX__!subrule"("", "") - new $P186, "ResizablePMCArray" - push $P186, $P185 - .return ($P186) + $P189 = self."!PREFIX__!subrule"("", "") + new $P190, "ResizablePMCArray" + push $P190, $P189 + .return ($P190) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym<[ ]>" :subid("51_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym<[ ]>" :subid("51_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx189_tgt - .local int rx189_pos - .local int rx189_off - .local int rx189_eos - .local int rx189_rep - .local pmc rx189_cur - (rx189_cur, rx189_pos, rx189_tgt) = self."!cursor_start"() - rx189_cur."!cursor_debug"("START ", "metachar:sym<[ ]>") - .lex unicode:"$\x{a2}", rx189_cur + .local string rx193_tgt + .local int rx193_pos + .local int rx193_off + .local int rx193_eos + .local int rx193_rep + .local pmc rx193_cur + (rx193_cur, rx193_pos, rx193_tgt) = self."!cursor_start"() + rx193_cur."!cursor_debug"("START ", "metachar:sym<[ ]>") + .lex unicode:"$\x{a2}", rx193_cur .local pmc match .lex "$/", match - length rx189_eos, rx189_tgt - gt rx189_pos, rx189_eos, rx189_done - set rx189_off, 0 - lt rx189_pos, 2, rx189_start - sub rx189_off, rx189_pos, 1 - substr rx189_tgt, rx189_tgt, rx189_off - rx189_start: + length rx193_eos, rx193_tgt + gt rx193_pos, rx193_eos, rx193_done + set rx193_off, 0 + lt rx193_pos, 2, rx193_start + sub rx193_off, rx193_pos, 1 + substr rx193_tgt, rx193_tgt, rx193_off + rx193_start: $I10 = self.'from'() - ne $I10, -1, rxscan193_done - goto rxscan193_scan - rxscan193_loop: - ($P10) = rx189_cur."from"() + ne $I10, -1, rxscan197_done + goto rxscan197_scan + rxscan197_loop: + ($P10) = rx193_cur."from"() inc $P10 - set rx189_pos, $P10 - ge rx189_pos, rx189_eos, rxscan193_done - rxscan193_scan: - set_addr $I10, rxscan193_loop - rx189_cur."!mark_push"(0, rx189_pos, $I10) - rxscan193_done: + set rx193_pos, $P10 + ge rx193_pos, rx193_eos, rxscan197_done + rxscan197_scan: + set_addr $I10, rxscan197_loop + rx193_cur."!mark_push"(0, rx193_pos, $I10) + rxscan197_done: .annotate 'line', 75 # rx literal "[" - add $I11, rx189_pos, 1 - gt $I11, rx189_eos, rx189_fail - sub $I11, rx189_pos, rx189_off - substr $S10, rx189_tgt, $I11, 1 - ne $S10, "[", rx189_fail - add rx189_pos, 1 + add $I11, rx193_pos, 1 + gt $I11, rx193_eos, rx193_fail + sub $I11, rx193_pos, rx193_off + substr $S10, rx193_tgt, $I11, 1 + ne $S10, "[", rx193_fail + add rx193_pos, 1 # rx subrule "nibbler" subtype=capture negate= - rx189_cur."!cursor_pos"(rx189_pos) - $P10 = rx189_cur."nibbler"() - unless $P10, rx189_fail - rx189_cur."!mark_push"(0, -1, 0, $P10) + rx193_cur."!cursor_pos"(rx193_pos) + $P10 = rx193_cur."nibbler"() + unless $P10, rx193_fail + rx193_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("nibbler") - rx189_pos = $P10."pos"() + rx193_pos = $P10."pos"() # rx literal "]" - add $I11, rx189_pos, 1 - gt $I11, rx189_eos, rx189_fail - sub $I11, rx189_pos, rx189_off - substr $S10, rx189_tgt, $I11, 1 - ne $S10, "]", rx189_fail - add rx189_pos, 1 + add $I11, rx193_pos, 1 + gt $I11, rx193_eos, rx193_fail + sub $I11, rx193_pos, rx193_off + substr $S10, rx193_tgt, $I11, 1 + ne $S10, "]", rx193_fail + add rx193_pos, 1 # rx pass - rx189_cur."!cursor_pass"(rx189_pos, "metachar:sym<[ ]>") - rx189_cur."!cursor_debug"("PASS ", "metachar:sym<[ ]>", " at pos=", rx189_pos) - .return (rx189_cur) - rx189_fail: -.annotate 'line', 3 - (rx189_rep, rx189_pos, $I10, $P10) = rx189_cur."!mark_fail"(0) - lt rx189_pos, -1, rx189_done - eq rx189_pos, -1, rx189_fail + rx193_cur."!cursor_pass"(rx193_pos, "metachar:sym<[ ]>") + rx193_cur."!cursor_debug"("PASS ", "metachar:sym<[ ]>", " at pos=", rx193_pos) + .return (rx193_cur) + rx193_fail: +.annotate 'line', 3 + (rx193_rep, rx193_pos, $I10, $P10) = rx193_cur."!mark_fail"(0) + lt rx193_pos, -1, rx193_done + eq rx193_pos, -1, rx193_fail jump $I10 - rx189_done: - rx189_cur."!cursor_fail"() - rx189_cur."!cursor_debug"("FAIL ", "metachar:sym<[ ]>") - .return (rx189_cur) + rx193_done: + rx193_cur."!cursor_fail"() + rx193_cur."!cursor_debug"("FAIL ", "metachar:sym<[ ]>") + .return (rx193_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym<[ ]>" :subid("52_1275511689.56967") :method +.sub "!PREFIX__metachar:sym<[ ]>" :subid("52_1275599996.35368") :method .annotate 'line', 3 - $P191 = self."!PREFIX__!subrule"("nibbler", "[") - new $P192, "ResizablePMCArray" - push $P192, $P191 - .return ($P192) + $P195 = self."!PREFIX__!subrule"("nibbler", "[") + new $P196, "ResizablePMCArray" + push $P196, $P195 + .return ($P196) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym<( )>" :subid("53_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym<( )>" :subid("53_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx195_tgt - .local int rx195_pos - .local int rx195_off - .local int rx195_eos - .local int rx195_rep - .local pmc rx195_cur - (rx195_cur, rx195_pos, rx195_tgt) = self."!cursor_start"() - rx195_cur."!cursor_debug"("START ", "metachar:sym<( )>") - .lex unicode:"$\x{a2}", rx195_cur + .local string rx199_tgt + .local int rx199_pos + .local int rx199_off + .local int rx199_eos + .local int rx199_rep + .local pmc rx199_cur + (rx199_cur, rx199_pos, rx199_tgt) = self."!cursor_start"() + rx199_cur."!cursor_debug"("START ", "metachar:sym<( )>") + .lex unicode:"$\x{a2}", rx199_cur .local pmc match .lex "$/", match - length rx195_eos, rx195_tgt - gt rx195_pos, rx195_eos, rx195_done - set rx195_off, 0 - lt rx195_pos, 2, rx195_start - sub rx195_off, rx195_pos, 1 - substr rx195_tgt, rx195_tgt, rx195_off - rx195_start: + length rx199_eos, rx199_tgt + gt rx199_pos, rx199_eos, rx199_done + set rx199_off, 0 + lt rx199_pos, 2, rx199_start + sub rx199_off, rx199_pos, 1 + substr rx199_tgt, rx199_tgt, rx199_off + rx199_start: $I10 = self.'from'() - ne $I10, -1, rxscan199_done - goto rxscan199_scan - rxscan199_loop: - ($P10) = rx195_cur."from"() + ne $I10, -1, rxscan203_done + goto rxscan203_scan + rxscan203_loop: + ($P10) = rx199_cur."from"() inc $P10 - set rx195_pos, $P10 - ge rx195_pos, rx195_eos, rxscan199_done - rxscan199_scan: - set_addr $I10, rxscan199_loop - rx195_cur."!mark_push"(0, rx195_pos, $I10) - rxscan199_done: + set rx199_pos, $P10 + ge rx199_pos, rx199_eos, rxscan203_done + rxscan203_scan: + set_addr $I10, rxscan203_loop + rx199_cur."!mark_push"(0, rx199_pos, $I10) + rxscan203_done: .annotate 'line', 76 # rx literal "(" - add $I11, rx195_pos, 1 - gt $I11, rx195_eos, rx195_fail - sub $I11, rx195_pos, rx195_off - substr $S10, rx195_tgt, $I11, 1 - ne $S10, "(", rx195_fail - add rx195_pos, 1 + add $I11, rx199_pos, 1 + gt $I11, rx199_eos, rx199_fail + sub $I11, rx199_pos, rx199_off + substr $S10, rx199_tgt, $I11, 1 + ne $S10, "(", rx199_fail + add rx199_pos, 1 # rx subrule "nibbler" subtype=capture negate= - rx195_cur."!cursor_pos"(rx195_pos) - $P10 = rx195_cur."nibbler"() - unless $P10, rx195_fail - rx195_cur."!mark_push"(0, -1, 0, $P10) + rx199_cur."!cursor_pos"(rx199_pos) + $P10 = rx199_cur."nibbler"() + unless $P10, rx199_fail + rx199_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("nibbler") - rx195_pos = $P10."pos"() + rx199_pos = $P10."pos"() # rx literal ")" - add $I11, rx195_pos, 1 - gt $I11, rx195_eos, rx195_fail - sub $I11, rx195_pos, rx195_off - substr $S10, rx195_tgt, $I11, 1 - ne $S10, ")", rx195_fail - add rx195_pos, 1 + add $I11, rx199_pos, 1 + gt $I11, rx199_eos, rx199_fail + sub $I11, rx199_pos, rx199_off + substr $S10, rx199_tgt, $I11, 1 + ne $S10, ")", rx199_fail + add rx199_pos, 1 # rx pass - rx195_cur."!cursor_pass"(rx195_pos, "metachar:sym<( )>") - rx195_cur."!cursor_debug"("PASS ", "metachar:sym<( )>", " at pos=", rx195_pos) - .return (rx195_cur) - rx195_fail: -.annotate 'line', 3 - (rx195_rep, rx195_pos, $I10, $P10) = rx195_cur."!mark_fail"(0) - lt rx195_pos, -1, rx195_done - eq rx195_pos, -1, rx195_fail + rx199_cur."!cursor_pass"(rx199_pos, "metachar:sym<( )>") + rx199_cur."!cursor_debug"("PASS ", "metachar:sym<( )>", " at pos=", rx199_pos) + .return (rx199_cur) + rx199_fail: +.annotate 'line', 3 + (rx199_rep, rx199_pos, $I10, $P10) = rx199_cur."!mark_fail"(0) + lt rx199_pos, -1, rx199_done + eq rx199_pos, -1, rx199_fail jump $I10 - rx195_done: - rx195_cur."!cursor_fail"() - rx195_cur."!cursor_debug"("FAIL ", "metachar:sym<( )>") - .return (rx195_cur) + rx199_done: + rx199_cur."!cursor_fail"() + rx199_cur."!cursor_debug"("FAIL ", "metachar:sym<( )>") + .return (rx199_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym<( )>" :subid("54_1275511689.56967") :method +.sub "!PREFIX__metachar:sym<( )>" :subid("54_1275599996.35368") :method .annotate 'line', 3 - $P197 = self."!PREFIX__!subrule"("nibbler", "(") - new $P198, "ResizablePMCArray" - push $P198, $P197 - .return ($P198) + $P201 = self."!PREFIX__!subrule"("nibbler", "(") + new $P202, "ResizablePMCArray" + push $P202, $P201 + .return ($P202) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym<'>" :subid("55_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym<'>" :subid("55_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx201_tgt - .local int rx201_pos - .local int rx201_off - .local int rx201_eos - .local int rx201_rep - .local pmc rx201_cur - (rx201_cur, rx201_pos, rx201_tgt) = self."!cursor_start"() - rx201_cur."!cursor_debug"("START ", "metachar:sym<'>") - .lex unicode:"$\x{a2}", rx201_cur + .local string rx205_tgt + .local int rx205_pos + .local int rx205_off + .local int rx205_eos + .local int rx205_rep + .local pmc rx205_cur + (rx205_cur, rx205_pos, rx205_tgt) = self."!cursor_start"() + rx205_cur."!cursor_debug"("START ", "metachar:sym<'>") + .lex unicode:"$\x{a2}", rx205_cur .local pmc match .lex "$/", match - length rx201_eos, rx201_tgt - gt rx201_pos, rx201_eos, rx201_done - set rx201_off, 0 - lt rx201_pos, 2, rx201_start - sub rx201_off, rx201_pos, 1 - substr rx201_tgt, rx201_tgt, rx201_off - rx201_start: + length rx205_eos, rx205_tgt + gt rx205_pos, rx205_eos, rx205_done + set rx205_off, 0 + lt rx205_pos, 2, rx205_start + sub rx205_off, rx205_pos, 1 + substr rx205_tgt, rx205_tgt, rx205_off + rx205_start: $I10 = self.'from'() - ne $I10, -1, rxscan204_done - goto rxscan204_scan - rxscan204_loop: - ($P10) = rx201_cur."from"() + ne $I10, -1, rxscan208_done + goto rxscan208_scan + rxscan208_loop: + ($P10) = rx205_cur."from"() inc $P10 - set rx201_pos, $P10 - ge rx201_pos, rx201_eos, rxscan204_done - rxscan204_scan: - set_addr $I10, rxscan204_loop - rx201_cur."!mark_push"(0, rx201_pos, $I10) - rxscan204_done: + set rx205_pos, $P10 + ge rx205_pos, rx205_eos, rxscan208_done + rxscan208_scan: + set_addr $I10, rxscan208_loop + rx205_cur."!mark_push"(0, rx205_pos, $I10) + rxscan208_done: .annotate 'line', 77 # rx enumcharlist negate=0 zerowidth - ge rx201_pos, rx201_eos, rx201_fail - sub $I10, rx201_pos, rx201_off - substr $S10, rx201_tgt, $I10, 1 + ge rx205_pos, rx205_eos, rx205_fail + sub $I10, rx205_pos, rx205_off + substr $S10, rx205_tgt, $I10, 1 index $I11, "'", $S10 - lt $I11, 0, rx201_fail + lt $I11, 0, rx205_fail # rx subrule "quote_EXPR" subtype=capture negate= - rx201_cur."!cursor_pos"(rx201_pos) - $P10 = rx201_cur."quote_EXPR"(":q") - unless $P10, rx201_fail - rx201_cur."!mark_push"(0, -1, 0, $P10) + rx205_cur."!cursor_pos"(rx205_pos) + $P10 = rx205_cur."quote_EXPR"(":q") + unless $P10, rx205_fail + rx205_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quote_EXPR") - rx201_pos = $P10."pos"() + rx205_pos = $P10."pos"() # rx pass - rx201_cur."!cursor_pass"(rx201_pos, "metachar:sym<'>") - rx201_cur."!cursor_debug"("PASS ", "metachar:sym<'>", " at pos=", rx201_pos) - .return (rx201_cur) - rx201_fail: -.annotate 'line', 3 - (rx201_rep, rx201_pos, $I10, $P10) = rx201_cur."!mark_fail"(0) - lt rx201_pos, -1, rx201_done - eq rx201_pos, -1, rx201_fail + rx205_cur."!cursor_pass"(rx205_pos, "metachar:sym<'>") + rx205_cur."!cursor_debug"("PASS ", "metachar:sym<'>", " at pos=", rx205_pos) + .return (rx205_cur) + rx205_fail: +.annotate 'line', 3 + (rx205_rep, rx205_pos, $I10, $P10) = rx205_cur."!mark_fail"(0) + lt rx205_pos, -1, rx205_done + eq rx205_pos, -1, rx205_fail jump $I10 - rx201_done: - rx201_cur."!cursor_fail"() - rx201_cur."!cursor_debug"("FAIL ", "metachar:sym<'>") - .return (rx201_cur) + rx205_done: + rx205_cur."!cursor_fail"() + rx205_cur."!cursor_debug"("FAIL ", "metachar:sym<'>") + .return (rx205_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym<'>" :subid("56_1275511689.56967") :method +.sub "!PREFIX__metachar:sym<'>" :subid("56_1275599996.35368") :method .annotate 'line', 3 - new $P203, "ResizablePMCArray" - push $P203, "'" - .return ($P203) + new $P207, "ResizablePMCArray" + push $P207, "'" + .return ($P207) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym<\">" :subid("57_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym<\">" :subid("57_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx206_tgt - .local int rx206_pos - .local int rx206_off - .local int rx206_eos - .local int rx206_rep - .local pmc rx206_cur - (rx206_cur, rx206_pos, rx206_tgt) = self."!cursor_start"() - rx206_cur."!cursor_debug"("START ", "metachar:sym<\">") - .lex unicode:"$\x{a2}", rx206_cur + .local string rx210_tgt + .local int rx210_pos + .local int rx210_off + .local int rx210_eos + .local int rx210_rep + .local pmc rx210_cur + (rx210_cur, rx210_pos, rx210_tgt) = self."!cursor_start"() + rx210_cur."!cursor_debug"("START ", "metachar:sym<\">") + .lex unicode:"$\x{a2}", rx210_cur .local pmc match .lex "$/", match - length rx206_eos, rx206_tgt - gt rx206_pos, rx206_eos, rx206_done - set rx206_off, 0 - lt rx206_pos, 2, rx206_start - sub rx206_off, rx206_pos, 1 - substr rx206_tgt, rx206_tgt, rx206_off - rx206_start: + length rx210_eos, rx210_tgt + gt rx210_pos, rx210_eos, rx210_done + set rx210_off, 0 + lt rx210_pos, 2, rx210_start + sub rx210_off, rx210_pos, 1 + substr rx210_tgt, rx210_tgt, rx210_off + rx210_start: $I10 = self.'from'() - ne $I10, -1, rxscan209_done - goto rxscan209_scan - rxscan209_loop: - ($P10) = rx206_cur."from"() + ne $I10, -1, rxscan213_done + goto rxscan213_scan + rxscan213_loop: + ($P10) = rx210_cur."from"() inc $P10 - set rx206_pos, $P10 - ge rx206_pos, rx206_eos, rxscan209_done - rxscan209_scan: - set_addr $I10, rxscan209_loop - rx206_cur."!mark_push"(0, rx206_pos, $I10) - rxscan209_done: + set rx210_pos, $P10 + ge rx210_pos, rx210_eos, rxscan213_done + rxscan213_scan: + set_addr $I10, rxscan213_loop + rx210_cur."!mark_push"(0, rx210_pos, $I10) + rxscan213_done: .annotate 'line', 78 # rx enumcharlist negate=0 zerowidth - ge rx206_pos, rx206_eos, rx206_fail - sub $I10, rx206_pos, rx206_off - substr $S10, rx206_tgt, $I10, 1 + ge rx210_pos, rx210_eos, rx210_fail + sub $I10, rx210_pos, rx210_off + substr $S10, rx210_tgt, $I10, 1 index $I11, "\"", $S10 - lt $I11, 0, rx206_fail + lt $I11, 0, rx210_fail # rx subrule "quote_EXPR" subtype=capture negate= - rx206_cur."!cursor_pos"(rx206_pos) - $P10 = rx206_cur."quote_EXPR"(":qq") - unless $P10, rx206_fail - rx206_cur."!mark_push"(0, -1, 0, $P10) + rx210_cur."!cursor_pos"(rx210_pos) + $P10 = rx210_cur."quote_EXPR"(":qq") + unless $P10, rx210_fail + rx210_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quote_EXPR") - rx206_pos = $P10."pos"() + rx210_pos = $P10."pos"() # rx pass - rx206_cur."!cursor_pass"(rx206_pos, "metachar:sym<\">") - rx206_cur."!cursor_debug"("PASS ", "metachar:sym<\">", " at pos=", rx206_pos) - .return (rx206_cur) - rx206_fail: -.annotate 'line', 3 - (rx206_rep, rx206_pos, $I10, $P10) = rx206_cur."!mark_fail"(0) - lt rx206_pos, -1, rx206_done - eq rx206_pos, -1, rx206_fail + rx210_cur."!cursor_pass"(rx210_pos, "metachar:sym<\">") + rx210_cur."!cursor_debug"("PASS ", "metachar:sym<\">", " at pos=", rx210_pos) + .return (rx210_cur) + rx210_fail: +.annotate 'line', 3 + (rx210_rep, rx210_pos, $I10, $P10) = rx210_cur."!mark_fail"(0) + lt rx210_pos, -1, rx210_done + eq rx210_pos, -1, rx210_fail jump $I10 - rx206_done: - rx206_cur."!cursor_fail"() - rx206_cur."!cursor_debug"("FAIL ", "metachar:sym<\">") - .return (rx206_cur) + rx210_done: + rx210_cur."!cursor_fail"() + rx210_cur."!cursor_debug"("FAIL ", "metachar:sym<\">") + .return (rx210_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym<\">" :subid("58_1275511689.56967") :method +.sub "!PREFIX__metachar:sym<\">" :subid("58_1275599996.35368") :method .annotate 'line', 3 - new $P208, "ResizablePMCArray" - push $P208, "\"" - .return ($P208) + new $P212, "ResizablePMCArray" + push $P212, "\"" + .return ($P212) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym<.>" :subid("59_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym<.>" :subid("59_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx211_tgt - .local int rx211_pos - .local int rx211_off - .local int rx211_eos - .local int rx211_rep - .local pmc rx211_cur - (rx211_cur, rx211_pos, rx211_tgt) = self."!cursor_start"() - rx211_cur."!cursor_debug"("START ", "metachar:sym<.>") - .lex unicode:"$\x{a2}", rx211_cur + .local string rx215_tgt + .local int rx215_pos + .local int rx215_off + .local int rx215_eos + .local int rx215_rep + .local pmc rx215_cur + (rx215_cur, rx215_pos, rx215_tgt) = self."!cursor_start"() + rx215_cur."!cursor_debug"("START ", "metachar:sym<.>") + .lex unicode:"$\x{a2}", rx215_cur .local pmc match .lex "$/", match - length rx211_eos, rx211_tgt - gt rx211_pos, rx211_eos, rx211_done - set rx211_off, 0 - lt rx211_pos, 2, rx211_start - sub rx211_off, rx211_pos, 1 - substr rx211_tgt, rx211_tgt, rx211_off - rx211_start: + length rx215_eos, rx215_tgt + gt rx215_pos, rx215_eos, rx215_done + set rx215_off, 0 + lt rx215_pos, 2, rx215_start + sub rx215_off, rx215_pos, 1 + substr rx215_tgt, rx215_tgt, rx215_off + rx215_start: $I10 = self.'from'() - ne $I10, -1, rxscan214_done - goto rxscan214_scan - rxscan214_loop: - ($P10) = rx211_cur."from"() + ne $I10, -1, rxscan218_done + goto rxscan218_scan + rxscan218_loop: + ($P10) = rx215_cur."from"() inc $P10 - set rx211_pos, $P10 - ge rx211_pos, rx211_eos, rxscan214_done - rxscan214_scan: - set_addr $I10, rxscan214_loop - rx211_cur."!mark_push"(0, rx211_pos, $I10) - rxscan214_done: + set rx215_pos, $P10 + ge rx215_pos, rx215_eos, rxscan218_done + rxscan218_scan: + set_addr $I10, rxscan218_loop + rx215_cur."!mark_push"(0, rx215_pos, $I10) + rxscan218_done: .annotate 'line', 79 # rx subcapture "sym" - set_addr $I10, rxcap_215_fail - rx211_cur."!mark_push"(0, rx211_pos, $I10) + set_addr $I10, rxcap_219_fail + rx215_cur."!mark_push"(0, rx215_pos, $I10) # rx literal "." - add $I11, rx211_pos, 1 - gt $I11, rx211_eos, rx211_fail - sub $I11, rx211_pos, rx211_off - substr $S10, rx211_tgt, $I11, 1 - ne $S10, ".", rx211_fail - add rx211_pos, 1 - set_addr $I10, rxcap_215_fail - ($I12, $I11) = rx211_cur."!mark_peek"($I10) - rx211_cur."!cursor_pos"($I11) - ($P10) = rx211_cur."!cursor_start"() - $P10."!cursor_pass"(rx211_pos, "") - rx211_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx215_pos, 1 + gt $I11, rx215_eos, rx215_fail + sub $I11, rx215_pos, rx215_off + substr $S10, rx215_tgt, $I11, 1 + ne $S10, ".", rx215_fail + add rx215_pos, 1 + set_addr $I10, rxcap_219_fail + ($I12, $I11) = rx215_cur."!mark_peek"($I10) + rx215_cur."!cursor_pos"($I11) + ($P10) = rx215_cur."!cursor_start"() + $P10."!cursor_pass"(rx215_pos, "") + rx215_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_215_done - rxcap_215_fail: - goto rx211_fail - rxcap_215_done: + goto rxcap_219_done + rxcap_219_fail: + goto rx215_fail + rxcap_219_done: # rx pass - rx211_cur."!cursor_pass"(rx211_pos, "metachar:sym<.>") - rx211_cur."!cursor_debug"("PASS ", "metachar:sym<.>", " at pos=", rx211_pos) - .return (rx211_cur) - rx211_fail: -.annotate 'line', 3 - (rx211_rep, rx211_pos, $I10, $P10) = rx211_cur."!mark_fail"(0) - lt rx211_pos, -1, rx211_done - eq rx211_pos, -1, rx211_fail + rx215_cur."!cursor_pass"(rx215_pos, "metachar:sym<.>") + rx215_cur."!cursor_debug"("PASS ", "metachar:sym<.>", " at pos=", rx215_pos) + .return (rx215_cur) + rx215_fail: +.annotate 'line', 3 + (rx215_rep, rx215_pos, $I10, $P10) = rx215_cur."!mark_fail"(0) + lt rx215_pos, -1, rx215_done + eq rx215_pos, -1, rx215_fail jump $I10 - rx211_done: - rx211_cur."!cursor_fail"() - rx211_cur."!cursor_debug"("FAIL ", "metachar:sym<.>") - .return (rx211_cur) + rx215_done: + rx215_cur."!cursor_fail"() + rx215_cur."!cursor_debug"("FAIL ", "metachar:sym<.>") + .return (rx215_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym<.>" :subid("60_1275511689.56967") :method +.sub "!PREFIX__metachar:sym<.>" :subid("60_1275599996.35368") :method .annotate 'line', 3 - new $P213, "ResizablePMCArray" - push $P213, "." - .return ($P213) + new $P217, "ResizablePMCArray" + push $P217, "." + .return ($P217) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym<^>" :subid("61_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym<^>" :subid("61_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx217_tgt - .local int rx217_pos - .local int rx217_off - .local int rx217_eos - .local int rx217_rep - .local pmc rx217_cur - (rx217_cur, rx217_pos, rx217_tgt) = self."!cursor_start"() - rx217_cur."!cursor_debug"("START ", "metachar:sym<^>") - .lex unicode:"$\x{a2}", rx217_cur + .local string rx221_tgt + .local int rx221_pos + .local int rx221_off + .local int rx221_eos + .local int rx221_rep + .local pmc rx221_cur + (rx221_cur, rx221_pos, rx221_tgt) = self."!cursor_start"() + rx221_cur."!cursor_debug"("START ", "metachar:sym<^>") + .lex unicode:"$\x{a2}", rx221_cur .local pmc match .lex "$/", match - length rx217_eos, rx217_tgt - gt rx217_pos, rx217_eos, rx217_done - set rx217_off, 0 - lt rx217_pos, 2, rx217_start - sub rx217_off, rx217_pos, 1 - substr rx217_tgt, rx217_tgt, rx217_off - rx217_start: + length rx221_eos, rx221_tgt + gt rx221_pos, rx221_eos, rx221_done + set rx221_off, 0 + lt rx221_pos, 2, rx221_start + sub rx221_off, rx221_pos, 1 + substr rx221_tgt, rx221_tgt, rx221_off + rx221_start: $I10 = self.'from'() - ne $I10, -1, rxscan220_done - goto rxscan220_scan - rxscan220_loop: - ($P10) = rx217_cur."from"() + ne $I10, -1, rxscan224_done + goto rxscan224_scan + rxscan224_loop: + ($P10) = rx221_cur."from"() inc $P10 - set rx217_pos, $P10 - ge rx217_pos, rx217_eos, rxscan220_done - rxscan220_scan: - set_addr $I10, rxscan220_loop - rx217_cur."!mark_push"(0, rx217_pos, $I10) - rxscan220_done: + set rx221_pos, $P10 + ge rx221_pos, rx221_eos, rxscan224_done + rxscan224_scan: + set_addr $I10, rxscan224_loop + rx221_cur."!mark_push"(0, rx221_pos, $I10) + rxscan224_done: .annotate 'line', 80 # rx subcapture "sym" - set_addr $I10, rxcap_221_fail - rx217_cur."!mark_push"(0, rx217_pos, $I10) + set_addr $I10, rxcap_225_fail + rx221_cur."!mark_push"(0, rx221_pos, $I10) # rx literal "^" - add $I11, rx217_pos, 1 - gt $I11, rx217_eos, rx217_fail - sub $I11, rx217_pos, rx217_off - substr $S10, rx217_tgt, $I11, 1 - ne $S10, "^", rx217_fail - add rx217_pos, 1 - set_addr $I10, rxcap_221_fail - ($I12, $I11) = rx217_cur."!mark_peek"($I10) - rx217_cur."!cursor_pos"($I11) - ($P10) = rx217_cur."!cursor_start"() - $P10."!cursor_pass"(rx217_pos, "") - rx217_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx221_pos, 1 + gt $I11, rx221_eos, rx221_fail + sub $I11, rx221_pos, rx221_off + substr $S10, rx221_tgt, $I11, 1 + ne $S10, "^", rx221_fail + add rx221_pos, 1 + set_addr $I10, rxcap_225_fail + ($I12, $I11) = rx221_cur."!mark_peek"($I10) + rx221_cur."!cursor_pos"($I11) + ($P10) = rx221_cur."!cursor_start"() + $P10."!cursor_pass"(rx221_pos, "") + rx221_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_221_done - rxcap_221_fail: - goto rx217_fail - rxcap_221_done: + goto rxcap_225_done + rxcap_225_fail: + goto rx221_fail + rxcap_225_done: # rx pass - rx217_cur."!cursor_pass"(rx217_pos, "metachar:sym<^>") - rx217_cur."!cursor_debug"("PASS ", "metachar:sym<^>", " at pos=", rx217_pos) - .return (rx217_cur) - rx217_fail: -.annotate 'line', 3 - (rx217_rep, rx217_pos, $I10, $P10) = rx217_cur."!mark_fail"(0) - lt rx217_pos, -1, rx217_done - eq rx217_pos, -1, rx217_fail + rx221_cur."!cursor_pass"(rx221_pos, "metachar:sym<^>") + rx221_cur."!cursor_debug"("PASS ", "metachar:sym<^>", " at pos=", rx221_pos) + .return (rx221_cur) + rx221_fail: +.annotate 'line', 3 + (rx221_rep, rx221_pos, $I10, $P10) = rx221_cur."!mark_fail"(0) + lt rx221_pos, -1, rx221_done + eq rx221_pos, -1, rx221_fail jump $I10 - rx217_done: - rx217_cur."!cursor_fail"() - rx217_cur."!cursor_debug"("FAIL ", "metachar:sym<^>") - .return (rx217_cur) + rx221_done: + rx221_cur."!cursor_fail"() + rx221_cur."!cursor_debug"("FAIL ", "metachar:sym<^>") + .return (rx221_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym<^>" :subid("62_1275511689.56967") :method +.sub "!PREFIX__metachar:sym<^>" :subid("62_1275599996.35368") :method .annotate 'line', 3 - new $P219, "ResizablePMCArray" - push $P219, "^" - .return ($P219) + new $P223, "ResizablePMCArray" + push $P223, "^" + .return ($P223) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym<^^>" :subid("63_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym<^^>" :subid("63_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx223_tgt - .local int rx223_pos - .local int rx223_off - .local int rx223_eos - .local int rx223_rep - .local pmc rx223_cur - (rx223_cur, rx223_pos, rx223_tgt) = self."!cursor_start"() - rx223_cur."!cursor_debug"("START ", "metachar:sym<^^>") - .lex unicode:"$\x{a2}", rx223_cur + .local string rx227_tgt + .local int rx227_pos + .local int rx227_off + .local int rx227_eos + .local int rx227_rep + .local pmc rx227_cur + (rx227_cur, rx227_pos, rx227_tgt) = self."!cursor_start"() + rx227_cur."!cursor_debug"("START ", "metachar:sym<^^>") + .lex unicode:"$\x{a2}", rx227_cur .local pmc match .lex "$/", match - length rx223_eos, rx223_tgt - gt rx223_pos, rx223_eos, rx223_done - set rx223_off, 0 - lt rx223_pos, 2, rx223_start - sub rx223_off, rx223_pos, 1 - substr rx223_tgt, rx223_tgt, rx223_off - rx223_start: + length rx227_eos, rx227_tgt + gt rx227_pos, rx227_eos, rx227_done + set rx227_off, 0 + lt rx227_pos, 2, rx227_start + sub rx227_off, rx227_pos, 1 + substr rx227_tgt, rx227_tgt, rx227_off + rx227_start: $I10 = self.'from'() - ne $I10, -1, rxscan226_done - goto rxscan226_scan - rxscan226_loop: - ($P10) = rx223_cur."from"() + ne $I10, -1, rxscan230_done + goto rxscan230_scan + rxscan230_loop: + ($P10) = rx227_cur."from"() inc $P10 - set rx223_pos, $P10 - ge rx223_pos, rx223_eos, rxscan226_done - rxscan226_scan: - set_addr $I10, rxscan226_loop - rx223_cur."!mark_push"(0, rx223_pos, $I10) - rxscan226_done: + set rx227_pos, $P10 + ge rx227_pos, rx227_eos, rxscan230_done + rxscan230_scan: + set_addr $I10, rxscan230_loop + rx227_cur."!mark_push"(0, rx227_pos, $I10) + rxscan230_done: .annotate 'line', 81 # rx subcapture "sym" - set_addr $I10, rxcap_227_fail - rx223_cur."!mark_push"(0, rx223_pos, $I10) + set_addr $I10, rxcap_231_fail + rx227_cur."!mark_push"(0, rx227_pos, $I10) # rx literal "^^" - add $I11, rx223_pos, 2 - gt $I11, rx223_eos, rx223_fail - sub $I11, rx223_pos, rx223_off - substr $S10, rx223_tgt, $I11, 2 - ne $S10, "^^", rx223_fail - add rx223_pos, 2 - set_addr $I10, rxcap_227_fail - ($I12, $I11) = rx223_cur."!mark_peek"($I10) - rx223_cur."!cursor_pos"($I11) - ($P10) = rx223_cur."!cursor_start"() - $P10."!cursor_pass"(rx223_pos, "") - rx223_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx227_pos, 2 + gt $I11, rx227_eos, rx227_fail + sub $I11, rx227_pos, rx227_off + substr $S10, rx227_tgt, $I11, 2 + ne $S10, "^^", rx227_fail + add rx227_pos, 2 + set_addr $I10, rxcap_231_fail + ($I12, $I11) = rx227_cur."!mark_peek"($I10) + rx227_cur."!cursor_pos"($I11) + ($P10) = rx227_cur."!cursor_start"() + $P10."!cursor_pass"(rx227_pos, "") + rx227_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_227_done - rxcap_227_fail: - goto rx223_fail - rxcap_227_done: + goto rxcap_231_done + rxcap_231_fail: + goto rx227_fail + rxcap_231_done: # rx pass - rx223_cur."!cursor_pass"(rx223_pos, "metachar:sym<^^>") - rx223_cur."!cursor_debug"("PASS ", "metachar:sym<^^>", " at pos=", rx223_pos) - .return (rx223_cur) - rx223_fail: -.annotate 'line', 3 - (rx223_rep, rx223_pos, $I10, $P10) = rx223_cur."!mark_fail"(0) - lt rx223_pos, -1, rx223_done - eq rx223_pos, -1, rx223_fail + rx227_cur."!cursor_pass"(rx227_pos, "metachar:sym<^^>") + rx227_cur."!cursor_debug"("PASS ", "metachar:sym<^^>", " at pos=", rx227_pos) + .return (rx227_cur) + rx227_fail: +.annotate 'line', 3 + (rx227_rep, rx227_pos, $I10, $P10) = rx227_cur."!mark_fail"(0) + lt rx227_pos, -1, rx227_done + eq rx227_pos, -1, rx227_fail jump $I10 - rx223_done: - rx223_cur."!cursor_fail"() - rx223_cur."!cursor_debug"("FAIL ", "metachar:sym<^^>") - .return (rx223_cur) + rx227_done: + rx227_cur."!cursor_fail"() + rx227_cur."!cursor_debug"("FAIL ", "metachar:sym<^^>") + .return (rx227_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym<^^>" :subid("64_1275511689.56967") :method +.sub "!PREFIX__metachar:sym<^^>" :subid("64_1275599996.35368") :method .annotate 'line', 3 - new $P225, "ResizablePMCArray" - push $P225, "^^" - .return ($P225) + new $P229, "ResizablePMCArray" + push $P229, "^^" + .return ($P229) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym<$>" :subid("65_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym<$>" :subid("65_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx229_tgt - .local int rx229_pos - .local int rx229_off - .local int rx229_eos - .local int rx229_rep - .local pmc rx229_cur - (rx229_cur, rx229_pos, rx229_tgt) = self."!cursor_start"() - rx229_cur."!cursor_debug"("START ", "metachar:sym<$>") - .lex unicode:"$\x{a2}", rx229_cur + .local string rx233_tgt + .local int rx233_pos + .local int rx233_off + .local int rx233_eos + .local int rx233_rep + .local pmc rx233_cur + (rx233_cur, rx233_pos, rx233_tgt) = self."!cursor_start"() + rx233_cur."!cursor_debug"("START ", "metachar:sym<$>") + .lex unicode:"$\x{a2}", rx233_cur .local pmc match .lex "$/", match - length rx229_eos, rx229_tgt - gt rx229_pos, rx229_eos, rx229_done - set rx229_off, 0 - lt rx229_pos, 2, rx229_start - sub rx229_off, rx229_pos, 1 - substr rx229_tgt, rx229_tgt, rx229_off - rx229_start: + length rx233_eos, rx233_tgt + gt rx233_pos, rx233_eos, rx233_done + set rx233_off, 0 + lt rx233_pos, 2, rx233_start + sub rx233_off, rx233_pos, 1 + substr rx233_tgt, rx233_tgt, rx233_off + rx233_start: $I10 = self.'from'() - ne $I10, -1, rxscan232_done - goto rxscan232_scan - rxscan232_loop: - ($P10) = rx229_cur."from"() + ne $I10, -1, rxscan236_done + goto rxscan236_scan + rxscan236_loop: + ($P10) = rx233_cur."from"() inc $P10 - set rx229_pos, $P10 - ge rx229_pos, rx229_eos, rxscan232_done - rxscan232_scan: - set_addr $I10, rxscan232_loop - rx229_cur."!mark_push"(0, rx229_pos, $I10) - rxscan232_done: + set rx233_pos, $P10 + ge rx233_pos, rx233_eos, rxscan236_done + rxscan236_scan: + set_addr $I10, rxscan236_loop + rx233_cur."!mark_push"(0, rx233_pos, $I10) + rxscan236_done: .annotate 'line', 82 # rx subcapture "sym" - set_addr $I10, rxcap_233_fail - rx229_cur."!mark_push"(0, rx229_pos, $I10) + set_addr $I10, rxcap_237_fail + rx233_cur."!mark_push"(0, rx233_pos, $I10) # rx literal "$" - add $I11, rx229_pos, 1 - gt $I11, rx229_eos, rx229_fail - sub $I11, rx229_pos, rx229_off - substr $S10, rx229_tgt, $I11, 1 - ne $S10, "$", rx229_fail - add rx229_pos, 1 - set_addr $I10, rxcap_233_fail - ($I12, $I11) = rx229_cur."!mark_peek"($I10) - rx229_cur."!cursor_pos"($I11) - ($P10) = rx229_cur."!cursor_start"() - $P10."!cursor_pass"(rx229_pos, "") - rx229_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx233_pos, 1 + gt $I11, rx233_eos, rx233_fail + sub $I11, rx233_pos, rx233_off + substr $S10, rx233_tgt, $I11, 1 + ne $S10, "$", rx233_fail + add rx233_pos, 1 + set_addr $I10, rxcap_237_fail + ($I12, $I11) = rx233_cur."!mark_peek"($I10) + rx233_cur."!cursor_pos"($I11) + ($P10) = rx233_cur."!cursor_start"() + $P10."!cursor_pass"(rx233_pos, "") + rx233_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_233_done - rxcap_233_fail: - goto rx229_fail - rxcap_233_done: + goto rxcap_237_done + rxcap_237_fail: + goto rx233_fail + rxcap_237_done: # rx pass - rx229_cur."!cursor_pass"(rx229_pos, "metachar:sym<$>") - rx229_cur."!cursor_debug"("PASS ", "metachar:sym<$>", " at pos=", rx229_pos) - .return (rx229_cur) - rx229_fail: -.annotate 'line', 3 - (rx229_rep, rx229_pos, $I10, $P10) = rx229_cur."!mark_fail"(0) - lt rx229_pos, -1, rx229_done - eq rx229_pos, -1, rx229_fail + rx233_cur."!cursor_pass"(rx233_pos, "metachar:sym<$>") + rx233_cur."!cursor_debug"("PASS ", "metachar:sym<$>", " at pos=", rx233_pos) + .return (rx233_cur) + rx233_fail: +.annotate 'line', 3 + (rx233_rep, rx233_pos, $I10, $P10) = rx233_cur."!mark_fail"(0) + lt rx233_pos, -1, rx233_done + eq rx233_pos, -1, rx233_fail jump $I10 - rx229_done: - rx229_cur."!cursor_fail"() - rx229_cur."!cursor_debug"("FAIL ", "metachar:sym<$>") - .return (rx229_cur) + rx233_done: + rx233_cur."!cursor_fail"() + rx233_cur."!cursor_debug"("FAIL ", "metachar:sym<$>") + .return (rx233_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym<$>" :subid("66_1275511689.56967") :method +.sub "!PREFIX__metachar:sym<$>" :subid("66_1275599996.35368") :method .annotate 'line', 3 - new $P231, "ResizablePMCArray" - push $P231, "$" - .return ($P231) + new $P235, "ResizablePMCArray" + push $P235, "$" + .return ($P235) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym<$$>" :subid("67_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym<$$>" :subid("67_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx235_tgt - .local int rx235_pos - .local int rx235_off - .local int rx235_eos - .local int rx235_rep - .local pmc rx235_cur - (rx235_cur, rx235_pos, rx235_tgt) = self."!cursor_start"() - rx235_cur."!cursor_debug"("START ", "metachar:sym<$$>") - .lex unicode:"$\x{a2}", rx235_cur + .local string rx239_tgt + .local int rx239_pos + .local int rx239_off + .local int rx239_eos + .local int rx239_rep + .local pmc rx239_cur + (rx239_cur, rx239_pos, rx239_tgt) = self."!cursor_start"() + rx239_cur."!cursor_debug"("START ", "metachar:sym<$$>") + .lex unicode:"$\x{a2}", rx239_cur .local pmc match .lex "$/", match - length rx235_eos, rx235_tgt - gt rx235_pos, rx235_eos, rx235_done - set rx235_off, 0 - lt rx235_pos, 2, rx235_start - sub rx235_off, rx235_pos, 1 - substr rx235_tgt, rx235_tgt, rx235_off - rx235_start: + length rx239_eos, rx239_tgt + gt rx239_pos, rx239_eos, rx239_done + set rx239_off, 0 + lt rx239_pos, 2, rx239_start + sub rx239_off, rx239_pos, 1 + substr rx239_tgt, rx239_tgt, rx239_off + rx239_start: $I10 = self.'from'() - ne $I10, -1, rxscan238_done - goto rxscan238_scan - rxscan238_loop: - ($P10) = rx235_cur."from"() + ne $I10, -1, rxscan242_done + goto rxscan242_scan + rxscan242_loop: + ($P10) = rx239_cur."from"() inc $P10 - set rx235_pos, $P10 - ge rx235_pos, rx235_eos, rxscan238_done - rxscan238_scan: - set_addr $I10, rxscan238_loop - rx235_cur."!mark_push"(0, rx235_pos, $I10) - rxscan238_done: + set rx239_pos, $P10 + ge rx239_pos, rx239_eos, rxscan242_done + rxscan242_scan: + set_addr $I10, rxscan242_loop + rx239_cur."!mark_push"(0, rx239_pos, $I10) + rxscan242_done: .annotate 'line', 83 # rx subcapture "sym" - set_addr $I10, rxcap_239_fail - rx235_cur."!mark_push"(0, rx235_pos, $I10) + set_addr $I10, rxcap_243_fail + rx239_cur."!mark_push"(0, rx239_pos, $I10) # rx literal "$$" - add $I11, rx235_pos, 2 - gt $I11, rx235_eos, rx235_fail - sub $I11, rx235_pos, rx235_off - substr $S10, rx235_tgt, $I11, 2 - ne $S10, "$$", rx235_fail - add rx235_pos, 2 - set_addr $I10, rxcap_239_fail - ($I12, $I11) = rx235_cur."!mark_peek"($I10) - rx235_cur."!cursor_pos"($I11) - ($P10) = rx235_cur."!cursor_start"() - $P10."!cursor_pass"(rx235_pos, "") - rx235_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx239_pos, 2 + gt $I11, rx239_eos, rx239_fail + sub $I11, rx239_pos, rx239_off + substr $S10, rx239_tgt, $I11, 2 + ne $S10, "$$", rx239_fail + add rx239_pos, 2 + set_addr $I10, rxcap_243_fail + ($I12, $I11) = rx239_cur."!mark_peek"($I10) + rx239_cur."!cursor_pos"($I11) + ($P10) = rx239_cur."!cursor_start"() + $P10."!cursor_pass"(rx239_pos, "") + rx239_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_239_done - rxcap_239_fail: - goto rx235_fail - rxcap_239_done: + goto rxcap_243_done + rxcap_243_fail: + goto rx239_fail + rxcap_243_done: # rx pass - rx235_cur."!cursor_pass"(rx235_pos, "metachar:sym<$$>") - rx235_cur."!cursor_debug"("PASS ", "metachar:sym<$$>", " at pos=", rx235_pos) - .return (rx235_cur) - rx235_fail: -.annotate 'line', 3 - (rx235_rep, rx235_pos, $I10, $P10) = rx235_cur."!mark_fail"(0) - lt rx235_pos, -1, rx235_done - eq rx235_pos, -1, rx235_fail + rx239_cur."!cursor_pass"(rx239_pos, "metachar:sym<$$>") + rx239_cur."!cursor_debug"("PASS ", "metachar:sym<$$>", " at pos=", rx239_pos) + .return (rx239_cur) + rx239_fail: +.annotate 'line', 3 + (rx239_rep, rx239_pos, $I10, $P10) = rx239_cur."!mark_fail"(0) + lt rx239_pos, -1, rx239_done + eq rx239_pos, -1, rx239_fail jump $I10 - rx235_done: - rx235_cur."!cursor_fail"() - rx235_cur."!cursor_debug"("FAIL ", "metachar:sym<$$>") - .return (rx235_cur) + rx239_done: + rx239_cur."!cursor_fail"() + rx239_cur."!cursor_debug"("FAIL ", "metachar:sym<$$>") + .return (rx239_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym<$$>" :subid("68_1275511689.56967") :method +.sub "!PREFIX__metachar:sym<$$>" :subid("68_1275599996.35368") :method .annotate 'line', 3 - new $P237, "ResizablePMCArray" - push $P237, "$$" - .return ($P237) + new $P241, "ResizablePMCArray" + push $P241, "$$" + .return ($P241) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym<:::>" :subid("69_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym<:::>" :subid("69_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx241_tgt - .local int rx241_pos - .local int rx241_off - .local int rx241_eos - .local int rx241_rep - .local pmc rx241_cur - (rx241_cur, rx241_pos, rx241_tgt) = self."!cursor_start"() - rx241_cur."!cursor_debug"("START ", "metachar:sym<:::>") - .lex unicode:"$\x{a2}", rx241_cur + .local string rx245_tgt + .local int rx245_pos + .local int rx245_off + .local int rx245_eos + .local int rx245_rep + .local pmc rx245_cur + (rx245_cur, rx245_pos, rx245_tgt) = self."!cursor_start"() + rx245_cur."!cursor_debug"("START ", "metachar:sym<:::>") + .lex unicode:"$\x{a2}", rx245_cur .local pmc match .lex "$/", match - length rx241_eos, rx241_tgt - gt rx241_pos, rx241_eos, rx241_done - set rx241_off, 0 - lt rx241_pos, 2, rx241_start - sub rx241_off, rx241_pos, 1 - substr rx241_tgt, rx241_tgt, rx241_off - rx241_start: + length rx245_eos, rx245_tgt + gt rx245_pos, rx245_eos, rx245_done + set rx245_off, 0 + lt rx245_pos, 2, rx245_start + sub rx245_off, rx245_pos, 1 + substr rx245_tgt, rx245_tgt, rx245_off + rx245_start: $I10 = self.'from'() - ne $I10, -1, rxscan245_done - goto rxscan245_scan - rxscan245_loop: - ($P10) = rx241_cur."from"() + ne $I10, -1, rxscan249_done + goto rxscan249_scan + rxscan249_loop: + ($P10) = rx245_cur."from"() inc $P10 - set rx241_pos, $P10 - ge rx241_pos, rx241_eos, rxscan245_done - rxscan245_scan: - set_addr $I10, rxscan245_loop - rx241_cur."!mark_push"(0, rx241_pos, $I10) - rxscan245_done: + set rx245_pos, $P10 + ge rx245_pos, rx245_eos, rxscan249_done + rxscan249_scan: + set_addr $I10, rxscan249_loop + rx245_cur."!mark_push"(0, rx245_pos, $I10) + rxscan249_done: .annotate 'line', 84 # rx subcapture "sym" - set_addr $I10, rxcap_246_fail - rx241_cur."!mark_push"(0, rx241_pos, $I10) + set_addr $I10, rxcap_250_fail + rx245_cur."!mark_push"(0, rx245_pos, $I10) # rx literal ":::" - add $I11, rx241_pos, 3 - gt $I11, rx241_eos, rx241_fail - sub $I11, rx241_pos, rx241_off - substr $S10, rx241_tgt, $I11, 3 - ne $S10, ":::", rx241_fail - add rx241_pos, 3 - set_addr $I10, rxcap_246_fail - ($I12, $I11) = rx241_cur."!mark_peek"($I10) - rx241_cur."!cursor_pos"($I11) - ($P10) = rx241_cur."!cursor_start"() - $P10."!cursor_pass"(rx241_pos, "") - rx241_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx245_pos, 3 + gt $I11, rx245_eos, rx245_fail + sub $I11, rx245_pos, rx245_off + substr $S10, rx245_tgt, $I11, 3 + ne $S10, ":::", rx245_fail + add rx245_pos, 3 + set_addr $I10, rxcap_250_fail + ($I12, $I11) = rx245_cur."!mark_peek"($I10) + rx245_cur."!cursor_pos"($I11) + ($P10) = rx245_cur."!cursor_start"() + $P10."!cursor_pass"(rx245_pos, "") + rx245_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_246_done - rxcap_246_fail: - goto rx241_fail - rxcap_246_done: + goto rxcap_250_done + rxcap_250_fail: + goto rx245_fail + rxcap_250_done: # rx subrule "panic" subtype=method negate= - rx241_cur."!cursor_pos"(rx241_pos) - $P10 = rx241_cur."panic"("::: not yet implemented") - unless $P10, rx241_fail - rx241_pos = $P10."pos"() + rx245_cur."!cursor_pos"(rx245_pos) + $P10 = rx245_cur."panic"("::: not yet implemented") + unless $P10, rx245_fail + rx245_pos = $P10."pos"() # rx pass - rx241_cur."!cursor_pass"(rx241_pos, "metachar:sym<:::>") - rx241_cur."!cursor_debug"("PASS ", "metachar:sym<:::>", " at pos=", rx241_pos) - .return (rx241_cur) - rx241_fail: -.annotate 'line', 3 - (rx241_rep, rx241_pos, $I10, $P10) = rx241_cur."!mark_fail"(0) - lt rx241_pos, -1, rx241_done - eq rx241_pos, -1, rx241_fail + rx245_cur."!cursor_pass"(rx245_pos, "metachar:sym<:::>") + rx245_cur."!cursor_debug"("PASS ", "metachar:sym<:::>", " at pos=", rx245_pos) + .return (rx245_cur) + rx245_fail: +.annotate 'line', 3 + (rx245_rep, rx245_pos, $I10, $P10) = rx245_cur."!mark_fail"(0) + lt rx245_pos, -1, rx245_done + eq rx245_pos, -1, rx245_fail jump $I10 - rx241_done: - rx241_cur."!cursor_fail"() - rx241_cur."!cursor_debug"("FAIL ", "metachar:sym<:::>") - .return (rx241_cur) + rx245_done: + rx245_cur."!cursor_fail"() + rx245_cur."!cursor_debug"("FAIL ", "metachar:sym<:::>") + .return (rx245_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym<:::>" :subid("70_1275511689.56967") :method +.sub "!PREFIX__metachar:sym<:::>" :subid("70_1275599996.35368") :method .annotate 'line', 3 - $P243 = self."!PREFIX__!subrule"("", ":::") - new $P244, "ResizablePMCArray" - push $P244, $P243 - .return ($P244) + $P247 = self."!PREFIX__!subrule"("", ":::") + new $P248, "ResizablePMCArray" + push $P248, $P247 + .return ($P248) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym<::>" :subid("71_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym<::>" :subid("71_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx248_tgt - .local int rx248_pos - .local int rx248_off - .local int rx248_eos - .local int rx248_rep - .local pmc rx248_cur - (rx248_cur, rx248_pos, rx248_tgt) = self."!cursor_start"() - rx248_cur."!cursor_debug"("START ", "metachar:sym<::>") - .lex unicode:"$\x{a2}", rx248_cur + .local string rx252_tgt + .local int rx252_pos + .local int rx252_off + .local int rx252_eos + .local int rx252_rep + .local pmc rx252_cur + (rx252_cur, rx252_pos, rx252_tgt) = self."!cursor_start"() + rx252_cur."!cursor_debug"("START ", "metachar:sym<::>") + .lex unicode:"$\x{a2}", rx252_cur .local pmc match .lex "$/", match - length rx248_eos, rx248_tgt - gt rx248_pos, rx248_eos, rx248_done - set rx248_off, 0 - lt rx248_pos, 2, rx248_start - sub rx248_off, rx248_pos, 1 - substr rx248_tgt, rx248_tgt, rx248_off - rx248_start: + length rx252_eos, rx252_tgt + gt rx252_pos, rx252_eos, rx252_done + set rx252_off, 0 + lt rx252_pos, 2, rx252_start + sub rx252_off, rx252_pos, 1 + substr rx252_tgt, rx252_tgt, rx252_off + rx252_start: $I10 = self.'from'() - ne $I10, -1, rxscan252_done - goto rxscan252_scan - rxscan252_loop: - ($P10) = rx248_cur."from"() + ne $I10, -1, rxscan256_done + goto rxscan256_scan + rxscan256_loop: + ($P10) = rx252_cur."from"() inc $P10 - set rx248_pos, $P10 - ge rx248_pos, rx248_eos, rxscan252_done - rxscan252_scan: - set_addr $I10, rxscan252_loop - rx248_cur."!mark_push"(0, rx248_pos, $I10) - rxscan252_done: + set rx252_pos, $P10 + ge rx252_pos, rx252_eos, rxscan256_done + rxscan256_scan: + set_addr $I10, rxscan256_loop + rx252_cur."!mark_push"(0, rx252_pos, $I10) + rxscan256_done: .annotate 'line', 85 # rx subcapture "sym" - set_addr $I10, rxcap_253_fail - rx248_cur."!mark_push"(0, rx248_pos, $I10) + set_addr $I10, rxcap_257_fail + rx252_cur."!mark_push"(0, rx252_pos, $I10) # rx literal "::" - add $I11, rx248_pos, 2 - gt $I11, rx248_eos, rx248_fail - sub $I11, rx248_pos, rx248_off - substr $S10, rx248_tgt, $I11, 2 - ne $S10, "::", rx248_fail - add rx248_pos, 2 - set_addr $I10, rxcap_253_fail - ($I12, $I11) = rx248_cur."!mark_peek"($I10) - rx248_cur."!cursor_pos"($I11) - ($P10) = rx248_cur."!cursor_start"() - $P10."!cursor_pass"(rx248_pos, "") - rx248_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx252_pos, 2 + gt $I11, rx252_eos, rx252_fail + sub $I11, rx252_pos, rx252_off + substr $S10, rx252_tgt, $I11, 2 + ne $S10, "::", rx252_fail + add rx252_pos, 2 + set_addr $I10, rxcap_257_fail + ($I12, $I11) = rx252_cur."!mark_peek"($I10) + rx252_cur."!cursor_pos"($I11) + ($P10) = rx252_cur."!cursor_start"() + $P10."!cursor_pass"(rx252_pos, "") + rx252_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_253_done - rxcap_253_fail: - goto rx248_fail - rxcap_253_done: + goto rxcap_257_done + rxcap_257_fail: + goto rx252_fail + rxcap_257_done: # rx subrule "panic" subtype=method negate= - rx248_cur."!cursor_pos"(rx248_pos) - $P10 = rx248_cur."panic"(":: not yet implemented") - unless $P10, rx248_fail - rx248_pos = $P10."pos"() + rx252_cur."!cursor_pos"(rx252_pos) + $P10 = rx252_cur."panic"(":: not yet implemented") + unless $P10, rx252_fail + rx252_pos = $P10."pos"() # rx pass - rx248_cur."!cursor_pass"(rx248_pos, "metachar:sym<::>") - rx248_cur."!cursor_debug"("PASS ", "metachar:sym<::>", " at pos=", rx248_pos) - .return (rx248_cur) - rx248_fail: -.annotate 'line', 3 - (rx248_rep, rx248_pos, $I10, $P10) = rx248_cur."!mark_fail"(0) - lt rx248_pos, -1, rx248_done - eq rx248_pos, -1, rx248_fail + rx252_cur."!cursor_pass"(rx252_pos, "metachar:sym<::>") + rx252_cur."!cursor_debug"("PASS ", "metachar:sym<::>", " at pos=", rx252_pos) + .return (rx252_cur) + rx252_fail: +.annotate 'line', 3 + (rx252_rep, rx252_pos, $I10, $P10) = rx252_cur."!mark_fail"(0) + lt rx252_pos, -1, rx252_done + eq rx252_pos, -1, rx252_fail jump $I10 - rx248_done: - rx248_cur."!cursor_fail"() - rx248_cur."!cursor_debug"("FAIL ", "metachar:sym<::>") - .return (rx248_cur) + rx252_done: + rx252_cur."!cursor_fail"() + rx252_cur."!cursor_debug"("FAIL ", "metachar:sym<::>") + .return (rx252_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym<::>" :subid("72_1275511689.56967") :method +.sub "!PREFIX__metachar:sym<::>" :subid("72_1275599996.35368") :method .annotate 'line', 3 - $P250 = self."!PREFIX__!subrule"("", "::") - new $P251, "ResizablePMCArray" - push $P251, $P250 - .return ($P251) + $P254 = self."!PREFIX__!subrule"("", "::") + new $P255, "ResizablePMCArray" + push $P255, $P254 + .return ($P255) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym" :subid("73_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym" :subid("73_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx255_tgt - .local int rx255_pos - .local int rx255_off - .local int rx255_eos - .local int rx255_rep - .local pmc rx255_cur - (rx255_cur, rx255_pos, rx255_tgt) = self."!cursor_start"() - rx255_cur."!cursor_debug"("START ", "metachar:sym") - .lex unicode:"$\x{a2}", rx255_cur + .local string rx259_tgt + .local int rx259_pos + .local int rx259_off + .local int rx259_eos + .local int rx259_rep + .local pmc rx259_cur + (rx259_cur, rx259_pos, rx259_tgt) = self."!cursor_start"() + rx259_cur."!cursor_debug"("START ", "metachar:sym") + .lex unicode:"$\x{a2}", rx259_cur .local pmc match .lex "$/", match - length rx255_eos, rx255_tgt - gt rx255_pos, rx255_eos, rx255_done - set rx255_off, 0 - lt rx255_pos, 2, rx255_start - sub rx255_off, rx255_pos, 1 - substr rx255_tgt, rx255_tgt, rx255_off - rx255_start: + length rx259_eos, rx259_tgt + gt rx259_pos, rx259_eos, rx259_done + set rx259_off, 0 + lt rx259_pos, 2, rx259_start + sub rx259_off, rx259_pos, 1 + substr rx259_tgt, rx259_tgt, rx259_off + rx259_start: $I10 = self.'from'() - ne $I10, -1, rxscan258_done - goto rxscan258_scan - rxscan258_loop: - ($P10) = rx255_cur."from"() + ne $I10, -1, rxscan262_done + goto rxscan262_scan + rxscan262_loop: + ($P10) = rx259_cur."from"() inc $P10 - set rx255_pos, $P10 - ge rx255_pos, rx255_eos, rxscan258_done - rxscan258_scan: - set_addr $I10, rxscan258_loop - rx255_cur."!mark_push"(0, rx255_pos, $I10) - rxscan258_done: + set rx259_pos, $P10 + ge rx259_pos, rx259_eos, rxscan262_done + rxscan262_scan: + set_addr $I10, rxscan262_loop + rx259_cur."!mark_push"(0, rx259_pos, $I10) + rxscan262_done: .annotate 'line', 86 # rx subcapture "sym" - set_addr $I10, rxcap_260_fail - rx255_cur."!mark_push"(0, rx255_pos, $I10) - alt259_0: - set_addr $I10, alt259_1 - rx255_cur."!mark_push"(0, rx255_pos, $I10) + set_addr $I10, rxcap_264_fail + rx259_cur."!mark_push"(0, rx259_pos, $I10) + alt263_0: + set_addr $I10, alt263_1 + rx259_cur."!mark_push"(0, rx259_pos, $I10) # rx literal "<<" - add $I11, rx255_pos, 2 - gt $I11, rx255_eos, rx255_fail - sub $I11, rx255_pos, rx255_off - substr $S10, rx255_tgt, $I11, 2 - ne $S10, "<<", rx255_fail - add rx255_pos, 2 - goto alt259_end - alt259_1: + add $I11, rx259_pos, 2 + gt $I11, rx259_eos, rx259_fail + sub $I11, rx259_pos, rx259_off + substr $S10, rx259_tgt, $I11, 2 + ne $S10, "<<", rx259_fail + add rx259_pos, 2 + goto alt263_end + alt263_1: # rx literal unicode:"\x{ab}" - add $I11, rx255_pos, 1 - gt $I11, rx255_eos, rx255_fail - sub $I11, rx255_pos, rx255_off - substr $S10, rx255_tgt, $I11, 1 - ne $S10, unicode:"\x{ab}", rx255_fail - add rx255_pos, 1 - alt259_end: - set_addr $I10, rxcap_260_fail - ($I12, $I11) = rx255_cur."!mark_peek"($I10) - rx255_cur."!cursor_pos"($I11) - ($P10) = rx255_cur."!cursor_start"() - $P10."!cursor_pass"(rx255_pos, "") - rx255_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx259_pos, 1 + gt $I11, rx259_eos, rx259_fail + sub $I11, rx259_pos, rx259_off + substr $S10, rx259_tgt, $I11, 1 + ne $S10, unicode:"\x{ab}", rx259_fail + add rx259_pos, 1 + alt263_end: + set_addr $I10, rxcap_264_fail + ($I12, $I11) = rx259_cur."!mark_peek"($I10) + rx259_cur."!cursor_pos"($I11) + ($P10) = rx259_cur."!cursor_start"() + $P10."!cursor_pass"(rx259_pos, "") + rx259_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_260_done - rxcap_260_fail: - goto rx255_fail - rxcap_260_done: + goto rxcap_264_done + rxcap_264_fail: + goto rx259_fail + rxcap_264_done: # rx pass - rx255_cur."!cursor_pass"(rx255_pos, "metachar:sym") - rx255_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx255_pos) - .return (rx255_cur) - rx255_fail: -.annotate 'line', 3 - (rx255_rep, rx255_pos, $I10, $P10) = rx255_cur."!mark_fail"(0) - lt rx255_pos, -1, rx255_done - eq rx255_pos, -1, rx255_fail + rx259_cur."!cursor_pass"(rx259_pos, "metachar:sym") + rx259_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx259_pos) + .return (rx259_cur) + rx259_fail: +.annotate 'line', 3 + (rx259_rep, rx259_pos, $I10, $P10) = rx259_cur."!mark_fail"(0) + lt rx259_pos, -1, rx259_done + eq rx259_pos, -1, rx259_fail jump $I10 - rx255_done: - rx255_cur."!cursor_fail"() - rx255_cur."!cursor_debug"("FAIL ", "metachar:sym") - .return (rx255_cur) + rx259_done: + rx259_cur."!cursor_fail"() + rx259_cur."!cursor_debug"("FAIL ", "metachar:sym") + .return (rx259_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym" :subid("74_1275511689.56967") :method +.sub "!PREFIX__metachar:sym" :subid("74_1275599996.35368") :method .annotate 'line', 3 - new $P257, "ResizablePMCArray" - push $P257, unicode:"\x{ab}" - push $P257, "<<" - .return ($P257) + new $P261, "ResizablePMCArray" + push $P261, unicode:"\x{ab}" + push $P261, "<<" + .return ($P261) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym" :subid("75_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym" :subid("75_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx262_tgt - .local int rx262_pos - .local int rx262_off - .local int rx262_eos - .local int rx262_rep - .local pmc rx262_cur - (rx262_cur, rx262_pos, rx262_tgt) = self."!cursor_start"() - rx262_cur."!cursor_debug"("START ", "metachar:sym") - .lex unicode:"$\x{a2}", rx262_cur + .local string rx266_tgt + .local int rx266_pos + .local int rx266_off + .local int rx266_eos + .local int rx266_rep + .local pmc rx266_cur + (rx266_cur, rx266_pos, rx266_tgt) = self."!cursor_start"() + rx266_cur."!cursor_debug"("START ", "metachar:sym") + .lex unicode:"$\x{a2}", rx266_cur .local pmc match .lex "$/", match - length rx262_eos, rx262_tgt - gt rx262_pos, rx262_eos, rx262_done - set rx262_off, 0 - lt rx262_pos, 2, rx262_start - sub rx262_off, rx262_pos, 1 - substr rx262_tgt, rx262_tgt, rx262_off - rx262_start: + length rx266_eos, rx266_tgt + gt rx266_pos, rx266_eos, rx266_done + set rx266_off, 0 + lt rx266_pos, 2, rx266_start + sub rx266_off, rx266_pos, 1 + substr rx266_tgt, rx266_tgt, rx266_off + rx266_start: $I10 = self.'from'() - ne $I10, -1, rxscan265_done - goto rxscan265_scan - rxscan265_loop: - ($P10) = rx262_cur."from"() + ne $I10, -1, rxscan269_done + goto rxscan269_scan + rxscan269_loop: + ($P10) = rx266_cur."from"() inc $P10 - set rx262_pos, $P10 - ge rx262_pos, rx262_eos, rxscan265_done - rxscan265_scan: - set_addr $I10, rxscan265_loop - rx262_cur."!mark_push"(0, rx262_pos, $I10) - rxscan265_done: + set rx266_pos, $P10 + ge rx266_pos, rx266_eos, rxscan269_done + rxscan269_scan: + set_addr $I10, rxscan269_loop + rx266_cur."!mark_push"(0, rx266_pos, $I10) + rxscan269_done: .annotate 'line', 87 # rx subcapture "sym" - set_addr $I10, rxcap_267_fail - rx262_cur."!mark_push"(0, rx262_pos, $I10) - alt266_0: - set_addr $I10, alt266_1 - rx262_cur."!mark_push"(0, rx262_pos, $I10) + set_addr $I10, rxcap_271_fail + rx266_cur."!mark_push"(0, rx266_pos, $I10) + alt270_0: + set_addr $I10, alt270_1 + rx266_cur."!mark_push"(0, rx266_pos, $I10) # rx literal ">>" - add $I11, rx262_pos, 2 - gt $I11, rx262_eos, rx262_fail - sub $I11, rx262_pos, rx262_off - substr $S10, rx262_tgt, $I11, 2 - ne $S10, ">>", rx262_fail - add rx262_pos, 2 - goto alt266_end - alt266_1: + add $I11, rx266_pos, 2 + gt $I11, rx266_eos, rx266_fail + sub $I11, rx266_pos, rx266_off + substr $S10, rx266_tgt, $I11, 2 + ne $S10, ">>", rx266_fail + add rx266_pos, 2 + goto alt270_end + alt270_1: # rx literal unicode:"\x{bb}" - add $I11, rx262_pos, 1 - gt $I11, rx262_eos, rx262_fail - sub $I11, rx262_pos, rx262_off - substr $S10, rx262_tgt, $I11, 1 - ne $S10, unicode:"\x{bb}", rx262_fail - add rx262_pos, 1 - alt266_end: - set_addr $I10, rxcap_267_fail - ($I12, $I11) = rx262_cur."!mark_peek"($I10) - rx262_cur."!cursor_pos"($I11) - ($P10) = rx262_cur."!cursor_start"() - $P10."!cursor_pass"(rx262_pos, "") - rx262_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx266_pos, 1 + gt $I11, rx266_eos, rx266_fail + sub $I11, rx266_pos, rx266_off + substr $S10, rx266_tgt, $I11, 1 + ne $S10, unicode:"\x{bb}", rx266_fail + add rx266_pos, 1 + alt270_end: + set_addr $I10, rxcap_271_fail + ($I12, $I11) = rx266_cur."!mark_peek"($I10) + rx266_cur."!cursor_pos"($I11) + ($P10) = rx266_cur."!cursor_start"() + $P10."!cursor_pass"(rx266_pos, "") + rx266_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_267_done - rxcap_267_fail: - goto rx262_fail - rxcap_267_done: + goto rxcap_271_done + rxcap_271_fail: + goto rx266_fail + rxcap_271_done: # rx pass - rx262_cur."!cursor_pass"(rx262_pos, "metachar:sym") - rx262_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx262_pos) - .return (rx262_cur) - rx262_fail: -.annotate 'line', 3 - (rx262_rep, rx262_pos, $I10, $P10) = rx262_cur."!mark_fail"(0) - lt rx262_pos, -1, rx262_done - eq rx262_pos, -1, rx262_fail + rx266_cur."!cursor_pass"(rx266_pos, "metachar:sym") + rx266_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx266_pos) + .return (rx266_cur) + rx266_fail: +.annotate 'line', 3 + (rx266_rep, rx266_pos, $I10, $P10) = rx266_cur."!mark_fail"(0) + lt rx266_pos, -1, rx266_done + eq rx266_pos, -1, rx266_fail jump $I10 - rx262_done: - rx262_cur."!cursor_fail"() - rx262_cur."!cursor_debug"("FAIL ", "metachar:sym") - .return (rx262_cur) + rx266_done: + rx266_cur."!cursor_fail"() + rx266_cur."!cursor_debug"("FAIL ", "metachar:sym") + .return (rx266_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym" :subid("76_1275511689.56967") :method +.sub "!PREFIX__metachar:sym" :subid("76_1275599996.35368") :method .annotate 'line', 3 - new $P264, "ResizablePMCArray" - push $P264, unicode:"\x{bb}" - push $P264, ">>" - .return ($P264) + new $P268, "ResizablePMCArray" + push $P268, unicode:"\x{bb}" + push $P268, ">>" + .return ($P268) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym" :subid("77_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym" :subid("77_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx269_tgt - .local int rx269_pos - .local int rx269_off - .local int rx269_eos - .local int rx269_rep - .local pmc rx269_cur - (rx269_cur, rx269_pos, rx269_tgt) = self."!cursor_start"() - rx269_cur."!cursor_debug"("START ", "metachar:sym") - .lex unicode:"$\x{a2}", rx269_cur + .local string rx273_tgt + .local int rx273_pos + .local int rx273_off + .local int rx273_eos + .local int rx273_rep + .local pmc rx273_cur + (rx273_cur, rx273_pos, rx273_tgt) = self."!cursor_start"() + rx273_cur."!cursor_debug"("START ", "metachar:sym") + .lex unicode:"$\x{a2}", rx273_cur .local pmc match .lex "$/", match - length rx269_eos, rx269_tgt - gt rx269_pos, rx269_eos, rx269_done - set rx269_off, 0 - lt rx269_pos, 2, rx269_start - sub rx269_off, rx269_pos, 1 - substr rx269_tgt, rx269_tgt, rx269_off - rx269_start: + length rx273_eos, rx273_tgt + gt rx273_pos, rx273_eos, rx273_done + set rx273_off, 0 + lt rx273_pos, 2, rx273_start + sub rx273_off, rx273_pos, 1 + substr rx273_tgt, rx273_tgt, rx273_off + rx273_start: $I10 = self.'from'() - ne $I10, -1, rxscan273_done - goto rxscan273_scan - rxscan273_loop: - ($P10) = rx269_cur."from"() + ne $I10, -1, rxscan277_done + goto rxscan277_scan + rxscan277_loop: + ($P10) = rx273_cur."from"() inc $P10 - set rx269_pos, $P10 - ge rx269_pos, rx269_eos, rxscan273_done - rxscan273_scan: - set_addr $I10, rxscan273_loop - rx269_cur."!mark_push"(0, rx269_pos, $I10) - rxscan273_done: + set rx273_pos, $P10 + ge rx273_pos, rx273_eos, rxscan277_done + rxscan277_scan: + set_addr $I10, rxscan277_loop + rx273_cur."!mark_push"(0, rx273_pos, $I10) + rxscan277_done: .annotate 'line', 88 # rx literal "\\" - add $I11, rx269_pos, 1 - gt $I11, rx269_eos, rx269_fail - sub $I11, rx269_pos, rx269_off - substr $S10, rx269_tgt, $I11, 1 - ne $S10, "\\", rx269_fail - add rx269_pos, 1 + add $I11, rx273_pos, 1 + gt $I11, rx273_eos, rx273_fail + sub $I11, rx273_pos, rx273_off + substr $S10, rx273_tgt, $I11, 1 + ne $S10, "\\", rx273_fail + add rx273_pos, 1 # rx subrule "backslash" subtype=capture negate= - rx269_cur."!cursor_pos"(rx269_pos) - $P10 = rx269_cur."backslash"() - unless $P10, rx269_fail - rx269_cur."!mark_push"(0, -1, 0, $P10) + rx273_cur."!cursor_pos"(rx273_pos) + $P10 = rx273_cur."backslash"() + unless $P10, rx273_fail + rx273_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("backslash") - rx269_pos = $P10."pos"() + rx273_pos = $P10."pos"() # rx pass - rx269_cur."!cursor_pass"(rx269_pos, "metachar:sym") - rx269_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx269_pos) - .return (rx269_cur) - rx269_fail: -.annotate 'line', 3 - (rx269_rep, rx269_pos, $I10, $P10) = rx269_cur."!mark_fail"(0) - lt rx269_pos, -1, rx269_done - eq rx269_pos, -1, rx269_fail + rx273_cur."!cursor_pass"(rx273_pos, "metachar:sym") + rx273_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx273_pos) + .return (rx273_cur) + rx273_fail: +.annotate 'line', 3 + (rx273_rep, rx273_pos, $I10, $P10) = rx273_cur."!mark_fail"(0) + lt rx273_pos, -1, rx273_done + eq rx273_pos, -1, rx273_fail jump $I10 - rx269_done: - rx269_cur."!cursor_fail"() - rx269_cur."!cursor_debug"("FAIL ", "metachar:sym") - .return (rx269_cur) + rx273_done: + rx273_cur."!cursor_fail"() + rx273_cur."!cursor_debug"("FAIL ", "metachar:sym") + .return (rx273_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym" :subid("78_1275511689.56967") :method +.sub "!PREFIX__metachar:sym" :subid("78_1275599996.35368") :method .annotate 'line', 3 - $P271 = self."!PREFIX__!subrule"("backslash", "\\") - new $P272, "ResizablePMCArray" - push $P272, $P271 - .return ($P272) + $P275 = self."!PREFIX__!subrule"("backslash", "\\") + new $P276, "ResizablePMCArray" + push $P276, $P275 + .return ($P276) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym" :subid("79_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym" :subid("79_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx275_tgt - .local int rx275_pos - .local int rx275_off - .local int rx275_eos - .local int rx275_rep - .local pmc rx275_cur - (rx275_cur, rx275_pos, rx275_tgt) = self."!cursor_start"() - rx275_cur."!cursor_debug"("START ", "metachar:sym") - .lex unicode:"$\x{a2}", rx275_cur + .local string rx279_tgt + .local int rx279_pos + .local int rx279_off + .local int rx279_eos + .local int rx279_rep + .local pmc rx279_cur + (rx279_cur, rx279_pos, rx279_tgt) = self."!cursor_start"() + rx279_cur."!cursor_debug"("START ", "metachar:sym") + .lex unicode:"$\x{a2}", rx279_cur .local pmc match .lex "$/", match - length rx275_eos, rx275_tgt - gt rx275_pos, rx275_eos, rx275_done - set rx275_off, 0 - lt rx275_pos, 2, rx275_start - sub rx275_off, rx275_pos, 1 - substr rx275_tgt, rx275_tgt, rx275_off - rx275_start: + length rx279_eos, rx279_tgt + gt rx279_pos, rx279_eos, rx279_done + set rx279_off, 0 + lt rx279_pos, 2, rx279_start + sub rx279_off, rx279_pos, 1 + substr rx279_tgt, rx279_tgt, rx279_off + rx279_start: $I10 = self.'from'() - ne $I10, -1, rxscan279_done - goto rxscan279_scan - rxscan279_loop: - ($P10) = rx275_cur."from"() + ne $I10, -1, rxscan283_done + goto rxscan283_scan + rxscan283_loop: + ($P10) = rx279_cur."from"() inc $P10 - set rx275_pos, $P10 - ge rx275_pos, rx275_eos, rxscan279_done - rxscan279_scan: - set_addr $I10, rxscan279_loop - rx275_cur."!mark_push"(0, rx275_pos, $I10) - rxscan279_done: + set rx279_pos, $P10 + ge rx279_pos, rx279_eos, rxscan283_done + rxscan283_scan: + set_addr $I10, rxscan283_loop + rx279_cur."!mark_push"(0, rx279_pos, $I10) + rxscan283_done: .annotate 'line', 89 # rx subrule "mod_internal" subtype=capture negate= - rx275_cur."!cursor_pos"(rx275_pos) - $P10 = rx275_cur."mod_internal"() - unless $P10, rx275_fail - rx275_cur."!mark_push"(0, -1, 0, $P10) + rx279_cur."!cursor_pos"(rx279_pos) + $P10 = rx279_cur."mod_internal"() + unless $P10, rx279_fail + rx279_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("mod_internal") - rx275_pos = $P10."pos"() + rx279_pos = $P10."pos"() # rx pass - rx275_cur."!cursor_pass"(rx275_pos, "metachar:sym") - rx275_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx275_pos) - .return (rx275_cur) - rx275_fail: -.annotate 'line', 3 - (rx275_rep, rx275_pos, $I10, $P10) = rx275_cur."!mark_fail"(0) - lt rx275_pos, -1, rx275_done - eq rx275_pos, -1, rx275_fail + rx279_cur."!cursor_pass"(rx279_pos, "metachar:sym") + rx279_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx279_pos) + .return (rx279_cur) + rx279_fail: +.annotate 'line', 3 + (rx279_rep, rx279_pos, $I10, $P10) = rx279_cur."!mark_fail"(0) + lt rx279_pos, -1, rx279_done + eq rx279_pos, -1, rx279_fail jump $I10 - rx275_done: - rx275_cur."!cursor_fail"() - rx275_cur."!cursor_debug"("FAIL ", "metachar:sym") - .return (rx275_cur) + rx279_done: + rx279_cur."!cursor_fail"() + rx279_cur."!cursor_debug"("FAIL ", "metachar:sym") + .return (rx279_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym" :subid("80_1275511689.56967") :method +.sub "!PREFIX__metachar:sym" :subid("80_1275599996.35368") :method .annotate 'line', 3 - $P277 = self."!PREFIX__!subrule"("mod_internal", "") - new $P278, "ResizablePMCArray" - push $P278, $P277 - .return ($P278) + $P281 = self."!PREFIX__!subrule"("mod_internal", "") + new $P282, "ResizablePMCArray" + push $P282, $P281 + .return ($P282) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym<~>" :subid("81_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym<~>" :subid("81_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx281_tgt - .local int rx281_pos - .local int rx281_off - .local int rx281_eos - .local int rx281_rep - .local pmc rx281_cur - (rx281_cur, rx281_pos, rx281_tgt) = self."!cursor_start"() - rx281_cur."!cursor_debug"("START ", "metachar:sym<~>") - .lex unicode:"$\x{a2}", rx281_cur + .local string rx285_tgt + .local int rx285_pos + .local int rx285_off + .local int rx285_eos + .local int rx285_rep + .local pmc rx285_cur + (rx285_cur, rx285_pos, rx285_tgt) = self."!cursor_start"() + rx285_cur."!cursor_debug"("START ", "metachar:sym<~>") + .lex unicode:"$\x{a2}", rx285_cur .local pmc match .lex "$/", match - length rx281_eos, rx281_tgt - gt rx281_pos, rx281_eos, rx281_done - set rx281_off, 0 - lt rx281_pos, 2, rx281_start - sub rx281_off, rx281_pos, 1 - substr rx281_tgt, rx281_tgt, rx281_off - rx281_start: + length rx285_eos, rx285_tgt + gt rx285_pos, rx285_eos, rx285_done + set rx285_off, 0 + lt rx285_pos, 2, rx285_start + sub rx285_off, rx285_pos, 1 + substr rx285_tgt, rx285_tgt, rx285_off + rx285_start: $I10 = self.'from'() - ne $I10, -1, rxscan285_done - goto rxscan285_scan - rxscan285_loop: - ($P10) = rx281_cur."from"() + ne $I10, -1, rxscan289_done + goto rxscan289_scan + rxscan289_loop: + ($P10) = rx285_cur."from"() inc $P10 - set rx281_pos, $P10 - ge rx281_pos, rx281_eos, rxscan285_done - rxscan285_scan: - set_addr $I10, rxscan285_loop - rx281_cur."!mark_push"(0, rx281_pos, $I10) - rxscan285_done: + set rx285_pos, $P10 + ge rx285_pos, rx285_eos, rxscan289_done + rxscan289_scan: + set_addr $I10, rxscan289_loop + rx285_cur."!mark_push"(0, rx285_pos, $I10) + rxscan289_done: .annotate 'line', 93 # rx subcapture "sym" - set_addr $I10, rxcap_286_fail - rx281_cur."!mark_push"(0, rx281_pos, $I10) + set_addr $I10, rxcap_290_fail + rx285_cur."!mark_push"(0, rx285_pos, $I10) # rx literal "~" - add $I11, rx281_pos, 1 - gt $I11, rx281_eos, rx281_fail - sub $I11, rx281_pos, rx281_off - substr $S10, rx281_tgt, $I11, 1 - ne $S10, "~", rx281_fail - add rx281_pos, 1 - set_addr $I10, rxcap_286_fail - ($I12, $I11) = rx281_cur."!mark_peek"($I10) - rx281_cur."!cursor_pos"($I11) - ($P10) = rx281_cur."!cursor_start"() - $P10."!cursor_pass"(rx281_pos, "") - rx281_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx285_pos, 1 + gt $I11, rx285_eos, rx285_fail + sub $I11, rx285_pos, rx285_off + substr $S10, rx285_tgt, $I11, 1 + ne $S10, "~", rx285_fail + add rx285_pos, 1 + set_addr $I10, rxcap_290_fail + ($I12, $I11) = rx285_cur."!mark_peek"($I10) + rx285_cur."!cursor_pos"($I11) + ($P10) = rx285_cur."!cursor_start"() + $P10."!cursor_pass"(rx285_pos, "") + rx285_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_286_done - rxcap_286_fail: - goto rx281_fail - rxcap_286_done: + goto rxcap_290_done + rxcap_290_fail: + goto rx285_fail + rxcap_290_done: .annotate 'line', 94 # rx subrule "ws" subtype=method negate= - rx281_cur."!cursor_pos"(rx281_pos) - $P10 = rx281_cur."ws"() - unless $P10, rx281_fail - rx281_pos = $P10."pos"() + rx285_cur."!cursor_pos"(rx285_pos) + $P10 = rx285_cur."ws"() + unless $P10, rx285_fail + rx285_pos = $P10."pos"() # rx subrule "quantified_atom" subtype=capture negate= - rx281_cur."!cursor_pos"(rx281_pos) - $P10 = rx281_cur."quantified_atom"() - unless $P10, rx281_fail - rx281_cur."!mark_push"(0, -1, 0, $P10) + rx285_cur."!cursor_pos"(rx285_pos) + $P10 = rx285_cur."quantified_atom"() + unless $P10, rx285_fail + rx285_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("GOAL") - rx281_pos = $P10."pos"() + rx285_pos = $P10."pos"() .annotate 'line', 95 # rx subrule "ws" subtype=method negate= - rx281_cur."!cursor_pos"(rx281_pos) - $P10 = rx281_cur."ws"() - unless $P10, rx281_fail - rx281_pos = $P10."pos"() + rx285_cur."!cursor_pos"(rx285_pos) + $P10 = rx285_cur."ws"() + unless $P10, rx285_fail + rx285_pos = $P10."pos"() # rx subrule "quantified_atom" subtype=capture negate= - rx281_cur."!cursor_pos"(rx281_pos) - $P10 = rx281_cur."quantified_atom"() - unless $P10, rx281_fail - rx281_cur."!mark_push"(0, -1, 0, $P10) + rx285_cur."!cursor_pos"(rx285_pos) + $P10 = rx285_cur."quantified_atom"() + unless $P10, rx285_fail + rx285_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("EXPR") - rx281_pos = $P10."pos"() + rx285_pos = $P10."pos"() .annotate 'line', 92 # rx pass - rx281_cur."!cursor_pass"(rx281_pos, "metachar:sym<~>") - rx281_cur."!cursor_debug"("PASS ", "metachar:sym<~>", " at pos=", rx281_pos) - .return (rx281_cur) - rx281_fail: -.annotate 'line', 3 - (rx281_rep, rx281_pos, $I10, $P10) = rx281_cur."!mark_fail"(0) - lt rx281_pos, -1, rx281_done - eq rx281_pos, -1, rx281_fail + rx285_cur."!cursor_pass"(rx285_pos, "metachar:sym<~>") + rx285_cur."!cursor_debug"("PASS ", "metachar:sym<~>", " at pos=", rx285_pos) + .return (rx285_cur) + rx285_fail: +.annotate 'line', 3 + (rx285_rep, rx285_pos, $I10, $P10) = rx285_cur."!mark_fail"(0) + lt rx285_pos, -1, rx285_done + eq rx285_pos, -1, rx285_fail jump $I10 - rx281_done: - rx281_cur."!cursor_fail"() - rx281_cur."!cursor_debug"("FAIL ", "metachar:sym<~>") - .return (rx281_cur) + rx285_done: + rx285_cur."!cursor_fail"() + rx285_cur."!cursor_debug"("FAIL ", "metachar:sym<~>") + .return (rx285_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym<~>" :subid("82_1275511689.56967") :method +.sub "!PREFIX__metachar:sym<~>" :subid("82_1275599996.35368") :method .annotate 'line', 3 - $P283 = self."!PREFIX__!subrule"("", "~") - new $P284, "ResizablePMCArray" - push $P284, $P283 - .return ($P284) + $P287 = self."!PREFIX__!subrule"("", "~") + new $P288, "ResizablePMCArray" + push $P288, $P287 + .return ($P288) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym<{*}>" :subid("83_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym<{*}>" :subid("83_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx288_tgt - .local int rx288_pos - .local int rx288_off - .local int rx288_eos - .local int rx288_rep - .local pmc rx288_cur - (rx288_cur, rx288_pos, rx288_tgt) = self."!cursor_start"() - rx288_cur."!cursor_debug"("START ", "metachar:sym<{*}>") - rx288_cur."!cursor_caparray"("key") - .lex unicode:"$\x{a2}", rx288_cur + .local string rx292_tgt + .local int rx292_pos + .local int rx292_off + .local int rx292_eos + .local int rx292_rep + .local pmc rx292_cur + (rx292_cur, rx292_pos, rx292_tgt) = self."!cursor_start"() + rx292_cur."!cursor_debug"("START ", "metachar:sym<{*}>") + rx292_cur."!cursor_caparray"("key") + .lex unicode:"$\x{a2}", rx292_cur .local pmc match .lex "$/", match - length rx288_eos, rx288_tgt - gt rx288_pos, rx288_eos, rx288_done - set rx288_off, 0 - lt rx288_pos, 2, rx288_start - sub rx288_off, rx288_pos, 1 - substr rx288_tgt, rx288_tgt, rx288_off - rx288_start: + length rx292_eos, rx292_tgt + gt rx292_pos, rx292_eos, rx292_done + set rx292_off, 0 + lt rx292_pos, 2, rx292_start + sub rx292_off, rx292_pos, 1 + substr rx292_tgt, rx292_tgt, rx292_off + rx292_start: $I10 = self.'from'() - ne $I10, -1, rxscan291_done - goto rxscan291_scan - rxscan291_loop: - ($P10) = rx288_cur."from"() + ne $I10, -1, rxscan295_done + goto rxscan295_scan + rxscan295_loop: + ($P10) = rx292_cur."from"() inc $P10 - set rx288_pos, $P10 - ge rx288_pos, rx288_eos, rxscan291_done - rxscan291_scan: - set_addr $I10, rxscan291_loop - rx288_cur."!mark_push"(0, rx288_pos, $I10) - rxscan291_done: + set rx292_pos, $P10 + ge rx292_pos, rx292_eos, rxscan295_done + rxscan295_scan: + set_addr $I10, rxscan295_loop + rx292_cur."!mark_push"(0, rx292_pos, $I10) + rxscan295_done: .annotate 'line', 99 # rx subcapture "sym" - set_addr $I10, rxcap_292_fail - rx288_cur."!mark_push"(0, rx288_pos, $I10) + set_addr $I10, rxcap_296_fail + rx292_cur."!mark_push"(0, rx292_pos, $I10) # rx literal "{*}" - add $I11, rx288_pos, 3 - gt $I11, rx288_eos, rx288_fail - sub $I11, rx288_pos, rx288_off - substr $S10, rx288_tgt, $I11, 3 - ne $S10, "{*}", rx288_fail - add rx288_pos, 3 - set_addr $I10, rxcap_292_fail - ($I12, $I11) = rx288_cur."!mark_peek"($I10) - rx288_cur."!cursor_pos"($I11) - ($P10) = rx288_cur."!cursor_start"() - $P10."!cursor_pass"(rx288_pos, "") - rx288_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx292_pos, 3 + gt $I11, rx292_eos, rx292_fail + sub $I11, rx292_pos, rx292_off + substr $S10, rx292_tgt, $I11, 3 + ne $S10, "{*}", rx292_fail + add rx292_pos, 3 + set_addr $I10, rxcap_296_fail + ($I12, $I11) = rx292_cur."!mark_peek"($I10) + rx292_cur."!cursor_pos"($I11) + ($P10) = rx292_cur."!cursor_start"() + $P10."!cursor_pass"(rx292_pos, "") + rx292_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_292_done - rxcap_292_fail: - goto rx288_fail - rxcap_292_done: + goto rxcap_296_done + rxcap_296_fail: + goto rx292_fail + rxcap_296_done: .annotate 'line', 100 - # rx rxquantr293 ** 0..1 - set_addr $I303, rxquantr293_done - rx288_cur."!mark_push"(0, rx288_pos, $I303) - rxquantr293_loop: - # rx rxquantr294 ** 0..* - set_addr $I295, rxquantr294_done - rx288_cur."!mark_push"(0, rx288_pos, $I295) - rxquantr294_loop: + # rx rxquantr297 ** 0..1 + set_addr $I307, rxquantr297_done + rx292_cur."!mark_push"(0, rx292_pos, $I307) + rxquantr297_loop: + # rx rxquantr298 ** 0..* + set_addr $I299, rxquantr298_done + rx292_cur."!mark_push"(0, rx292_pos, $I299) + rxquantr298_loop: # rx enumcharlist negate=0 - ge rx288_pos, rx288_eos, rx288_fail - sub $I10, rx288_pos, rx288_off - substr $S10, rx288_tgt, $I10, 1 + ge rx292_pos, rx292_eos, rx292_fail + sub $I10, rx292_pos, rx292_off + substr $S10, rx292_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx288_fail - inc rx288_pos - (rx288_rep) = rx288_cur."!mark_commit"($I295) - rx288_cur."!mark_push"(rx288_rep, rx288_pos, $I295) - goto rxquantr294_loop - rxquantr294_done: + lt $I11, 0, rx292_fail + inc rx292_pos + (rx292_rep) = rx292_cur."!mark_commit"($I299) + rx292_cur."!mark_push"(rx292_rep, rx292_pos, $I299) + goto rxquantr298_loop + rxquantr298_done: # rx literal "#= " - add $I11, rx288_pos, 3 - gt $I11, rx288_eos, rx288_fail - sub $I11, rx288_pos, rx288_off - substr $S10, rx288_tgt, $I11, 3 - ne $S10, "#= ", rx288_fail - add rx288_pos, 3 - # rx rxquantr296 ** 0..* - set_addr $I297, rxquantr296_done - rx288_cur."!mark_push"(0, rx288_pos, $I297) - rxquantr296_loop: + add $I11, rx292_pos, 3 + gt $I11, rx292_eos, rx292_fail + sub $I11, rx292_pos, rx292_off + substr $S10, rx292_tgt, $I11, 3 + ne $S10, "#= ", rx292_fail + add rx292_pos, 3 + # rx rxquantr300 ** 0..* + set_addr $I301, rxquantr300_done + rx292_cur."!mark_push"(0, rx292_pos, $I301) + rxquantr300_loop: # rx enumcharlist negate=0 - ge rx288_pos, rx288_eos, rx288_fail - sub $I10, rx288_pos, rx288_off - substr $S10, rx288_tgt, $I10, 1 + ge rx292_pos, rx292_eos, rx292_fail + sub $I10, rx292_pos, rx292_off + substr $S10, rx292_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx288_fail - inc rx288_pos - (rx288_rep) = rx288_cur."!mark_commit"($I297) - rx288_cur."!mark_push"(rx288_rep, rx288_pos, $I297) - goto rxquantr296_loop - rxquantr296_done: + lt $I11, 0, rx292_fail + inc rx292_pos + (rx292_rep) = rx292_cur."!mark_commit"($I301) + rx292_cur."!mark_push"(rx292_rep, rx292_pos, $I301) + goto rxquantr300_loop + rxquantr300_done: # rx subcapture "key" - set_addr $I10, rxcap_302_fail - rx288_cur."!mark_push"(0, rx288_pos, $I10) + set_addr $I10, rxcap_306_fail + rx292_cur."!mark_push"(0, rx292_pos, $I10) # rx charclass_q S r 1..-1 - sub $I10, rx288_pos, rx288_off - find_cclass $I11, 32, rx288_tgt, $I10, rx288_eos + sub $I10, rx292_pos, rx292_off + find_cclass $I11, 32, rx292_tgt, $I10, rx292_eos add $I12, $I10, 1 - lt $I11, $I12, rx288_fail - add rx288_pos, rx288_off, $I11 - # rx rxquantr298 ** 0..* - set_addr $I301, rxquantr298_done - rx288_cur."!mark_push"(0, rx288_pos, $I301) - rxquantr298_loop: - # rx rxquantr299 ** 1..* - set_addr $I300, rxquantr299_done - rx288_cur."!mark_push"(0, -1, $I300) - rxquantr299_loop: + lt $I11, $I12, rx292_fail + add rx292_pos, rx292_off, $I11 + # rx rxquantr302 ** 0..* + set_addr $I305, rxquantr302_done + rx292_cur."!mark_push"(0, rx292_pos, $I305) + rxquantr302_loop: + # rx rxquantr303 ** 1..* + set_addr $I304, rxquantr303_done + rx292_cur."!mark_push"(0, -1, $I304) + rxquantr303_loop: # rx enumcharlist negate=0 - ge rx288_pos, rx288_eos, rx288_fail - sub $I10, rx288_pos, rx288_off - substr $S10, rx288_tgt, $I10, 1 + ge rx292_pos, rx292_eos, rx292_fail + sub $I10, rx292_pos, rx292_off + substr $S10, rx292_tgt, $I10, 1 index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10 - lt $I11, 0, rx288_fail - inc rx288_pos - (rx288_rep) = rx288_cur."!mark_commit"($I300) - rx288_cur."!mark_push"(rx288_rep, rx288_pos, $I300) - goto rxquantr299_loop - rxquantr299_done: + lt $I11, 0, rx292_fail + inc rx292_pos + (rx292_rep) = rx292_cur."!mark_commit"($I304) + rx292_cur."!mark_push"(rx292_rep, rx292_pos, $I304) + goto rxquantr303_loop + rxquantr303_done: # rx charclass_q S r 1..-1 - sub $I10, rx288_pos, rx288_off - find_cclass $I11, 32, rx288_tgt, $I10, rx288_eos + sub $I10, rx292_pos, rx292_off + find_cclass $I11, 32, rx292_tgt, $I10, rx292_eos add $I12, $I10, 1 - lt $I11, $I12, rx288_fail - add rx288_pos, rx288_off, $I11 - (rx288_rep) = rx288_cur."!mark_commit"($I301) - rx288_cur."!mark_push"(rx288_rep, rx288_pos, $I301) - goto rxquantr298_loop - rxquantr298_done: - set_addr $I10, rxcap_302_fail - ($I12, $I11) = rx288_cur."!mark_peek"($I10) - rx288_cur."!cursor_pos"($I11) - ($P10) = rx288_cur."!cursor_start"() - $P10."!cursor_pass"(rx288_pos, "") - rx288_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, $I12, rx292_fail + add rx292_pos, rx292_off, $I11 + (rx292_rep) = rx292_cur."!mark_commit"($I305) + rx292_cur."!mark_push"(rx292_rep, rx292_pos, $I305) + goto rxquantr302_loop + rxquantr302_done: + set_addr $I10, rxcap_306_fail + ($I12, $I11) = rx292_cur."!mark_peek"($I10) + rx292_cur."!cursor_pos"($I11) + ($P10) = rx292_cur."!cursor_start"() + $P10."!cursor_pass"(rx292_pos, "") + rx292_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("key") - goto rxcap_302_done - rxcap_302_fail: - goto rx288_fail - rxcap_302_done: - (rx288_rep) = rx288_cur."!mark_commit"($I303) - rxquantr293_done: + goto rxcap_306_done + rxcap_306_fail: + goto rx292_fail + rxcap_306_done: + (rx292_rep) = rx292_cur."!mark_commit"($I307) + rxquantr297_done: .annotate 'line', 98 # rx pass - rx288_cur."!cursor_pass"(rx288_pos, "metachar:sym<{*}>") - rx288_cur."!cursor_debug"("PASS ", "metachar:sym<{*}>", " at pos=", rx288_pos) - .return (rx288_cur) - rx288_fail: -.annotate 'line', 3 - (rx288_rep, rx288_pos, $I10, $P10) = rx288_cur."!mark_fail"(0) - lt rx288_pos, -1, rx288_done - eq rx288_pos, -1, rx288_fail + rx292_cur."!cursor_pass"(rx292_pos, "metachar:sym<{*}>") + rx292_cur."!cursor_debug"("PASS ", "metachar:sym<{*}>", " at pos=", rx292_pos) + .return (rx292_cur) + rx292_fail: +.annotate 'line', 3 + (rx292_rep, rx292_pos, $I10, $P10) = rx292_cur."!mark_fail"(0) + lt rx292_pos, -1, rx292_done + eq rx292_pos, -1, rx292_fail jump $I10 - rx288_done: - rx288_cur."!cursor_fail"() - rx288_cur."!cursor_debug"("FAIL ", "metachar:sym<{*}>") - .return (rx288_cur) + rx292_done: + rx292_cur."!cursor_fail"() + rx292_cur."!cursor_debug"("FAIL ", "metachar:sym<{*}>") + .return (rx292_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym<{*}>" :subid("84_1275511689.56967") :method +.sub "!PREFIX__metachar:sym<{*}>" :subid("84_1275599996.35368") :method .annotate 'line', 3 - new $P290, "ResizablePMCArray" - push $P290, "{*}" - .return ($P290) + new $P294, "ResizablePMCArray" + push $P294, "{*}" + .return ($P294) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym" :subid("85_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym" :subid("85_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx305_tgt - .local int rx305_pos - .local int rx305_off - .local int rx305_eos - .local int rx305_rep - .local pmc rx305_cur - (rx305_cur, rx305_pos, rx305_tgt) = self."!cursor_start"() - rx305_cur."!cursor_debug"("START ", "metachar:sym") - .lex unicode:"$\x{a2}", rx305_cur + .local string rx309_tgt + .local int rx309_pos + .local int rx309_off + .local int rx309_eos + .local int rx309_rep + .local pmc rx309_cur + (rx309_cur, rx309_pos, rx309_tgt) = self."!cursor_start"() + rx309_cur."!cursor_debug"("START ", "metachar:sym") + .lex unicode:"$\x{a2}", rx309_cur .local pmc match .lex "$/", match - length rx305_eos, rx305_tgt - gt rx305_pos, rx305_eos, rx305_done - set rx305_off, 0 - lt rx305_pos, 2, rx305_start - sub rx305_off, rx305_pos, 1 - substr rx305_tgt, rx305_tgt, rx305_off - rx305_start: + length rx309_eos, rx309_tgt + gt rx309_pos, rx309_eos, rx309_done + set rx309_off, 0 + lt rx309_pos, 2, rx309_start + sub rx309_off, rx309_pos, 1 + substr rx309_tgt, rx309_tgt, rx309_off + rx309_start: $I10 = self.'from'() - ne $I10, -1, rxscan309_done - goto rxscan309_scan - rxscan309_loop: - ($P10) = rx305_cur."from"() + ne $I10, -1, rxscan313_done + goto rxscan313_scan + rxscan313_loop: + ($P10) = rx309_cur."from"() inc $P10 - set rx305_pos, $P10 - ge rx305_pos, rx305_eos, rxscan309_done - rxscan309_scan: - set_addr $I10, rxscan309_loop - rx305_cur."!mark_push"(0, rx305_pos, $I10) - rxscan309_done: + set rx309_pos, $P10 + ge rx309_pos, rx309_eos, rxscan313_done + rxscan313_scan: + set_addr $I10, rxscan313_loop + rx309_cur."!mark_push"(0, rx309_pos, $I10) + rxscan313_done: .annotate 'line', 103 # rx literal "<" - add $I11, rx305_pos, 1 - gt $I11, rx305_eos, rx305_fail - sub $I11, rx305_pos, rx305_off - substr $S10, rx305_tgt, $I11, 1 - ne $S10, "<", rx305_fail - add rx305_pos, 1 + add $I11, rx309_pos, 1 + gt $I11, rx309_eos, rx309_fail + sub $I11, rx309_pos, rx309_off + substr $S10, rx309_tgt, $I11, 1 + ne $S10, "<", rx309_fail + add rx309_pos, 1 # rx subrule "assertion" subtype=capture negate= - rx305_cur."!cursor_pos"(rx305_pos) - $P10 = rx305_cur."assertion"() - unless $P10, rx305_fail - rx305_cur."!mark_push"(0, -1, 0, $P10) + rx309_cur."!cursor_pos"(rx309_pos) + $P10 = rx309_cur."assertion"() + unless $P10, rx309_fail + rx309_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("assertion") - rx305_pos = $P10."pos"() - alt310_0: + rx309_pos = $P10."pos"() + alt314_0: .annotate 'line', 104 - set_addr $I10, alt310_1 - rx305_cur."!mark_push"(0, rx305_pos, $I10) + set_addr $I10, alt314_1 + rx309_cur."!mark_push"(0, rx309_pos, $I10) # rx literal ">" - add $I11, rx305_pos, 1 - gt $I11, rx305_eos, rx305_fail - sub $I11, rx305_pos, rx305_off - substr $S10, rx305_tgt, $I11, 1 - ne $S10, ">", rx305_fail - add rx305_pos, 1 - goto alt310_end - alt310_1: + add $I11, rx309_pos, 1 + gt $I11, rx309_eos, rx309_fail + sub $I11, rx309_pos, rx309_off + substr $S10, rx309_tgt, $I11, 1 + ne $S10, ">", rx309_fail + add rx309_pos, 1 + goto alt314_end + alt314_1: # rx subrule "panic" subtype=method negate= - rx305_cur."!cursor_pos"(rx305_pos) - $P10 = rx305_cur."panic"("regex assertion not terminated by angle bracket") - unless $P10, rx305_fail - rx305_pos = $P10."pos"() - alt310_end: + rx309_cur."!cursor_pos"(rx309_pos) + $P10 = rx309_cur."panic"("regex assertion not terminated by angle bracket") + unless $P10, rx309_fail + rx309_pos = $P10."pos"() + alt314_end: .annotate 'line', 102 # rx pass - rx305_cur."!cursor_pass"(rx305_pos, "metachar:sym") - rx305_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx305_pos) - .return (rx305_cur) - rx305_fail: -.annotate 'line', 3 - (rx305_rep, rx305_pos, $I10, $P10) = rx305_cur."!mark_fail"(0) - lt rx305_pos, -1, rx305_done - eq rx305_pos, -1, rx305_fail + rx309_cur."!cursor_pass"(rx309_pos, "metachar:sym") + rx309_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx309_pos) + .return (rx309_cur) + rx309_fail: +.annotate 'line', 3 + (rx309_rep, rx309_pos, $I10, $P10) = rx309_cur."!mark_fail"(0) + lt rx309_pos, -1, rx309_done + eq rx309_pos, -1, rx309_fail jump $I10 - rx305_done: - rx305_cur."!cursor_fail"() - rx305_cur."!cursor_debug"("FAIL ", "metachar:sym") - .return (rx305_cur) + rx309_done: + rx309_cur."!cursor_fail"() + rx309_cur."!cursor_debug"("FAIL ", "metachar:sym") + .return (rx309_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym" :subid("86_1275511689.56967") :method +.sub "!PREFIX__metachar:sym" :subid("86_1275599996.35368") :method .annotate 'line', 3 - $P307 = self."!PREFIX__!subrule"("assertion", "<") - new $P308, "ResizablePMCArray" - push $P308, $P307 - .return ($P308) + $P311 = self."!PREFIX__!subrule"("assertion", "<") + new $P312, "ResizablePMCArray" + push $P312, $P311 + .return ($P312) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym" :subid("87_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym" :subid("87_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx312_tgt - .local int rx312_pos - .local int rx312_off - .local int rx312_eos - .local int rx312_rep - .local pmc rx312_cur - (rx312_cur, rx312_pos, rx312_tgt) = self."!cursor_start"() - rx312_cur."!cursor_debug"("START ", "metachar:sym") - rx312_cur."!cursor_caparray"("quantified_atom") - .lex unicode:"$\x{a2}", rx312_cur + .local string rx316_tgt + .local int rx316_pos + .local int rx316_off + .local int rx316_eos + .local int rx316_rep + .local pmc rx316_cur + (rx316_cur, rx316_pos, rx316_tgt) = self."!cursor_start"() + rx316_cur."!cursor_debug"("START ", "metachar:sym") + rx316_cur."!cursor_caparray"("quantified_atom") + .lex unicode:"$\x{a2}", rx316_cur .local pmc match .lex "$/", match - length rx312_eos, rx312_tgt - gt rx312_pos, rx312_eos, rx312_done - set rx312_off, 0 - lt rx312_pos, 2, rx312_start - sub rx312_off, rx312_pos, 1 - substr rx312_tgt, rx312_tgt, rx312_off - rx312_start: + length rx316_eos, rx316_tgt + gt rx316_pos, rx316_eos, rx316_done + set rx316_off, 0 + lt rx316_pos, 2, rx316_start + sub rx316_off, rx316_pos, 1 + substr rx316_tgt, rx316_tgt, rx316_off + rx316_start: $I10 = self.'from'() - ne $I10, -1, rxscan315_done - goto rxscan315_scan - rxscan315_loop: - ($P10) = rx312_cur."from"() + ne $I10, -1, rxscan319_done + goto rxscan319_scan + rxscan319_loop: + ($P10) = rx316_cur."from"() inc $P10 - set rx312_pos, $P10 - ge rx312_pos, rx312_eos, rxscan315_done - rxscan315_scan: - set_addr $I10, rxscan315_loop - rx312_cur."!mark_push"(0, rx312_pos, $I10) - rxscan315_done: - alt316_0: + set rx316_pos, $P10 + ge rx316_pos, rx316_eos, rxscan319_done + rxscan319_scan: + set_addr $I10, rxscan319_loop + rx316_cur."!mark_push"(0, rx316_pos, $I10) + rxscan319_done: + alt320_0: .annotate 'line', 108 - set_addr $I10, alt316_1 - rx312_cur."!mark_push"(0, rx312_pos, $I10) + set_addr $I10, alt320_1 + rx316_cur."!mark_push"(0, rx316_pos, $I10) .annotate 'line', 109 # rx literal "$<" - add $I11, rx312_pos, 2 - gt $I11, rx312_eos, rx312_fail - sub $I11, rx312_pos, rx312_off - substr $S10, rx312_tgt, $I11, 2 - ne $S10, "$<", rx312_fail - add rx312_pos, 2 + add $I11, rx316_pos, 2 + gt $I11, rx316_eos, rx316_fail + sub $I11, rx316_pos, rx316_off + substr $S10, rx316_tgt, $I11, 2 + ne $S10, "$<", rx316_fail + add rx316_pos, 2 # rx subcapture "name" - set_addr $I10, rxcap_319_fail - rx312_cur."!mark_push"(0, rx312_pos, $I10) - # rx rxquantr317 ** 1..* - set_addr $I318, rxquantr317_done - rx312_cur."!mark_push"(0, -1, $I318) - rxquantr317_loop: + set_addr $I10, rxcap_323_fail + rx316_cur."!mark_push"(0, rx316_pos, $I10) + # rx rxquantr321 ** 1..* + set_addr $I322, rxquantr321_done + rx316_cur."!mark_push"(0, -1, $I322) + rxquantr321_loop: # rx enumcharlist negate=1 - ge rx312_pos, rx312_eos, rx312_fail - sub $I10, rx312_pos, rx312_off - substr $S10, rx312_tgt, $I10, 1 + ge rx316_pos, rx316_eos, rx316_fail + sub $I10, rx316_pos, rx316_off + substr $S10, rx316_tgt, $I10, 1 index $I11, ">", $S10 - ge $I11, 0, rx312_fail - inc rx312_pos - (rx312_rep) = rx312_cur."!mark_commit"($I318) - rx312_cur."!mark_push"(rx312_rep, rx312_pos, $I318) - goto rxquantr317_loop - rxquantr317_done: - set_addr $I10, rxcap_319_fail - ($I12, $I11) = rx312_cur."!mark_peek"($I10) - rx312_cur."!cursor_pos"($I11) - ($P10) = rx312_cur."!cursor_start"() - $P10."!cursor_pass"(rx312_pos, "") - rx312_cur."!mark_push"(0, -1, 0, $P10) + ge $I11, 0, rx316_fail + inc rx316_pos + (rx316_rep) = rx316_cur."!mark_commit"($I322) + rx316_cur."!mark_push"(rx316_rep, rx316_pos, $I322) + goto rxquantr321_loop + rxquantr321_done: + set_addr $I10, rxcap_323_fail + ($I12, $I11) = rx316_cur."!mark_peek"($I10) + rx316_cur."!cursor_pos"($I11) + ($P10) = rx316_cur."!cursor_start"() + $P10."!cursor_pass"(rx316_pos, "") + rx316_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("name") - goto rxcap_319_done - rxcap_319_fail: - goto rx312_fail - rxcap_319_done: + goto rxcap_323_done + rxcap_323_fail: + goto rx316_fail + rxcap_323_done: # rx literal ">" - add $I11, rx312_pos, 1 - gt $I11, rx312_eos, rx312_fail - sub $I11, rx312_pos, rx312_off - substr $S10, rx312_tgt, $I11, 1 - ne $S10, ">", rx312_fail - add rx312_pos, 1 - goto alt316_end - alt316_1: + add $I11, rx316_pos, 1 + gt $I11, rx316_eos, rx316_fail + sub $I11, rx316_pos, rx316_off + substr $S10, rx316_tgt, $I11, 1 + ne $S10, ">", rx316_fail + add rx316_pos, 1 + goto alt320_end + alt320_1: .annotate 'line', 110 # rx literal "$" - add $I11, rx312_pos, 1 - gt $I11, rx312_eos, rx312_fail - sub $I11, rx312_pos, rx312_off - substr $S10, rx312_tgt, $I11, 1 - ne $S10, "$", rx312_fail - add rx312_pos, 1 + add $I11, rx316_pos, 1 + gt $I11, rx316_eos, rx316_fail + sub $I11, rx316_pos, rx316_off + substr $S10, rx316_tgt, $I11, 1 + ne $S10, "$", rx316_fail + add rx316_pos, 1 # rx subcapture "pos" - set_addr $I10, rxcap_320_fail - rx312_cur."!mark_push"(0, rx312_pos, $I10) + set_addr $I10, rxcap_324_fail + rx316_cur."!mark_push"(0, rx316_pos, $I10) # rx charclass_q d r 1..-1 - sub $I10, rx312_pos, rx312_off - find_not_cclass $I11, 8, rx312_tgt, $I10, rx312_eos + sub $I10, rx316_pos, rx316_off + find_not_cclass $I11, 8, rx316_tgt, $I10, rx316_eos add $I12, $I10, 1 - lt $I11, $I12, rx312_fail - add rx312_pos, rx312_off, $I11 - set_addr $I10, rxcap_320_fail - ($I12, $I11) = rx312_cur."!mark_peek"($I10) - rx312_cur."!cursor_pos"($I11) - ($P10) = rx312_cur."!cursor_start"() - $P10."!cursor_pass"(rx312_pos, "") - rx312_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, $I12, rx316_fail + add rx316_pos, rx316_off, $I11 + set_addr $I10, rxcap_324_fail + ($I12, $I11) = rx316_cur."!mark_peek"($I10) + rx316_cur."!cursor_pos"($I11) + ($P10) = rx316_cur."!cursor_start"() + $P10."!cursor_pass"(rx316_pos, "") + rx316_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("pos") - goto rxcap_320_done - rxcap_320_fail: - goto rx312_fail - rxcap_320_done: - alt316_end: + goto rxcap_324_done + rxcap_324_fail: + goto rx316_fail + rxcap_324_done: + alt320_end: .annotate 'line', 113 - # rx rxquantr321 ** 0..1 - set_addr $I322, rxquantr321_done - rx312_cur."!mark_push"(0, rx312_pos, $I322) - rxquantr321_loop: + # rx rxquantr325 ** 0..1 + set_addr $I326, rxquantr325_done + rx316_cur."!mark_push"(0, rx316_pos, $I326) + rxquantr325_loop: # rx subrule "ws" subtype=method negate= - rx312_cur."!cursor_pos"(rx312_pos) - $P10 = rx312_cur."ws"() - unless $P10, rx312_fail - rx312_pos = $P10."pos"() + rx316_cur."!cursor_pos"(rx316_pos) + $P10 = rx316_cur."ws"() + unless $P10, rx316_fail + rx316_pos = $P10."pos"() # rx literal "=" - add $I11, rx312_pos, 1 - gt $I11, rx312_eos, rx312_fail - sub $I11, rx312_pos, rx312_off - substr $S10, rx312_tgt, $I11, 1 - ne $S10, "=", rx312_fail - add rx312_pos, 1 + add $I11, rx316_pos, 1 + gt $I11, rx316_eos, rx316_fail + sub $I11, rx316_pos, rx316_off + substr $S10, rx316_tgt, $I11, 1 + ne $S10, "=", rx316_fail + add rx316_pos, 1 # rx subrule "ws" subtype=method negate= - rx312_cur."!cursor_pos"(rx312_pos) - $P10 = rx312_cur."ws"() - unless $P10, rx312_fail - rx312_pos = $P10."pos"() + rx316_cur."!cursor_pos"(rx316_pos) + $P10 = rx316_cur."ws"() + unless $P10, rx316_fail + rx316_pos = $P10."pos"() # rx subrule "quantified_atom" subtype=capture negate= - rx312_cur."!cursor_pos"(rx312_pos) - $P10 = rx312_cur."quantified_atom"() - unless $P10, rx312_fail - rx312_cur."!mark_push"(0, -1, 0, $P10) + rx316_cur."!cursor_pos"(rx316_pos) + $P10 = rx316_cur."quantified_atom"() + unless $P10, rx316_fail + rx316_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("quantified_atom") - rx312_pos = $P10."pos"() - (rx312_rep) = rx312_cur."!mark_commit"($I322) - rxquantr321_done: + rx316_pos = $P10."pos"() + (rx316_rep) = rx316_cur."!mark_commit"($I326) + rxquantr325_done: .annotate 'line', 107 # rx pass - rx312_cur."!cursor_pass"(rx312_pos, "metachar:sym") - rx312_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx312_pos) - .return (rx312_cur) - rx312_fail: -.annotate 'line', 3 - (rx312_rep, rx312_pos, $I10, $P10) = rx312_cur."!mark_fail"(0) - lt rx312_pos, -1, rx312_done - eq rx312_pos, -1, rx312_fail + rx316_cur."!cursor_pass"(rx316_pos, "metachar:sym") + rx316_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx316_pos) + .return (rx316_cur) + rx316_fail: +.annotate 'line', 3 + (rx316_rep, rx316_pos, $I10, $P10) = rx316_cur."!mark_fail"(0) + lt rx316_pos, -1, rx316_done + eq rx316_pos, -1, rx316_fail jump $I10 - rx312_done: - rx312_cur."!cursor_fail"() - rx312_cur."!cursor_debug"("FAIL ", "metachar:sym") - .return (rx312_cur) + rx316_done: + rx316_cur."!cursor_fail"() + rx316_cur."!cursor_debug"("FAIL ", "metachar:sym") + .return (rx316_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym" :subid("88_1275511689.56967") :method +.sub "!PREFIX__metachar:sym" :subid("88_1275599996.35368") :method .annotate 'line', 3 - new $P314, "ResizablePMCArray" - push $P314, "$" - push $P314, "$<" - .return ($P314) + new $P318, "ResizablePMCArray" + push $P318, "$" + push $P318, "$<" + .return ($P318) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "metachar:sym" :subid("89_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "metachar:sym" :subid("89_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx324_tgt - .local int rx324_pos - .local int rx324_off - .local int rx324_eos - .local int rx324_rep - .local pmc rx324_cur - (rx324_cur, rx324_pos, rx324_tgt) = self."!cursor_start"() - rx324_cur."!cursor_debug"("START ", "metachar:sym") - .lex unicode:"$\x{a2}", rx324_cur + .local string rx328_tgt + .local int rx328_pos + .local int rx328_off + .local int rx328_eos + .local int rx328_rep + .local pmc rx328_cur + (rx328_cur, rx328_pos, rx328_tgt) = self."!cursor_start"() + rx328_cur."!cursor_debug"("START ", "metachar:sym") + .lex unicode:"$\x{a2}", rx328_cur .local pmc match .lex "$/", match - length rx324_eos, rx324_tgt - gt rx324_pos, rx324_eos, rx324_done - set rx324_off, 0 - lt rx324_pos, 2, rx324_start - sub rx324_off, rx324_pos, 1 - substr rx324_tgt, rx324_tgt, rx324_off - rx324_start: + length rx328_eos, rx328_tgt + gt rx328_pos, rx328_eos, rx328_done + set rx328_off, 0 + lt rx328_pos, 2, rx328_start + sub rx328_off, rx328_pos, 1 + substr rx328_tgt, rx328_tgt, rx328_off + rx328_start: $I10 = self.'from'() - ne $I10, -1, rxscan327_done - goto rxscan327_scan - rxscan327_loop: - ($P10) = rx324_cur."from"() + ne $I10, -1, rxscan331_done + goto rxscan331_scan + rxscan331_loop: + ($P10) = rx328_cur."from"() inc $P10 - set rx324_pos, $P10 - ge rx324_pos, rx324_eos, rxscan327_done - rxscan327_scan: - set_addr $I10, rxscan327_loop - rx324_cur."!mark_push"(0, rx324_pos, $I10) - rxscan327_done: + set rx328_pos, $P10 + ge rx328_pos, rx328_eos, rxscan331_done + rxscan331_scan: + set_addr $I10, rxscan331_loop + rx328_cur."!mark_push"(0, rx328_pos, $I10) + rxscan331_done: .annotate 'line', 117 # rx literal ":PIR{{" - add $I11, rx324_pos, 6 - gt $I11, rx324_eos, rx324_fail - sub $I11, rx324_pos, rx324_off - substr $S10, rx324_tgt, $I11, 6 - ne $S10, ":PIR{{", rx324_fail - add rx324_pos, 6 + add $I11, rx328_pos, 6 + gt $I11, rx328_eos, rx328_fail + sub $I11, rx328_pos, rx328_off + substr $S10, rx328_tgt, $I11, 6 + ne $S10, ":PIR{{", rx328_fail + add rx328_pos, 6 # rx subcapture "pir" - set_addr $I10, rxcap_330_fail - rx324_cur."!mark_push"(0, rx324_pos, $I10) - # rx rxquantf328 ** 0..* - set_addr $I10, rxquantf328_loop - rx324_cur."!mark_push"(0, rx324_pos, $I10) - goto rxquantf328_done - rxquantf328_loop: + set_addr $I10, rxcap_334_fail + rx328_cur."!mark_push"(0, rx328_pos, $I10) + # rx rxquantf332 ** 0..* + set_addr $I10, rxquantf332_loop + rx328_cur."!mark_push"(0, rx328_pos, $I10) + goto rxquantf332_done + rxquantf332_loop: # rx charclass . - ge rx324_pos, rx324_eos, rx324_fail - inc rx324_pos - set_addr $I10, rxquantf328_loop - rx324_cur."!mark_push"($I329, rx324_pos, $I10) - rxquantf328_done: - set_addr $I10, rxcap_330_fail - ($I12, $I11) = rx324_cur."!mark_peek"($I10) - rx324_cur."!cursor_pos"($I11) - ($P10) = rx324_cur."!cursor_start"() - $P10."!cursor_pass"(rx324_pos, "") - rx324_cur."!mark_push"(0, -1, 0, $P10) + ge rx328_pos, rx328_eos, rx328_fail + inc rx328_pos + set_addr $I10, rxquantf332_loop + rx328_cur."!mark_push"($I333, rx328_pos, $I10) + rxquantf332_done: + set_addr $I10, rxcap_334_fail + ($I12, $I11) = rx328_cur."!mark_peek"($I10) + rx328_cur."!cursor_pos"($I11) + ($P10) = rx328_cur."!cursor_start"() + $P10."!cursor_pass"(rx328_pos, "") + rx328_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("pir") - goto rxcap_330_done - rxcap_330_fail: - goto rx324_fail - rxcap_330_done: + goto rxcap_334_done + rxcap_334_fail: + goto rx328_fail + rxcap_334_done: # rx literal "}}" - add $I11, rx324_pos, 2 - gt $I11, rx324_eos, rx324_fail - sub $I11, rx324_pos, rx324_off - substr $S10, rx324_tgt, $I11, 2 - ne $S10, "}}", rx324_fail - add rx324_pos, 2 + add $I11, rx328_pos, 2 + gt $I11, rx328_eos, rx328_fail + sub $I11, rx328_pos, rx328_off + substr $S10, rx328_tgt, $I11, 2 + ne $S10, "}}", rx328_fail + add rx328_pos, 2 .annotate 'line', 116 # rx pass - rx324_cur."!cursor_pass"(rx324_pos, "metachar:sym") - rx324_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx324_pos) - .return (rx324_cur) - rx324_fail: -.annotate 'line', 3 - (rx324_rep, rx324_pos, $I10, $P10) = rx324_cur."!mark_fail"(0) - lt rx324_pos, -1, rx324_done - eq rx324_pos, -1, rx324_fail + rx328_cur."!cursor_pass"(rx328_pos, "metachar:sym") + rx328_cur."!cursor_debug"("PASS ", "metachar:sym", " at pos=", rx328_pos) + .return (rx328_cur) + rx328_fail: +.annotate 'line', 3 + (rx328_rep, rx328_pos, $I10, $P10) = rx328_cur."!mark_fail"(0) + lt rx328_pos, -1, rx328_done + eq rx328_pos, -1, rx328_fail jump $I10 - rx324_done: - rx324_cur."!cursor_fail"() - rx324_cur."!cursor_debug"("FAIL ", "metachar:sym") - .return (rx324_cur) + rx328_done: + rx328_cur."!cursor_fail"() + rx328_cur."!cursor_debug"("FAIL ", "metachar:sym") + .return (rx328_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__metachar:sym" :subid("90_1275511689.56967") :method +.sub "!PREFIX__metachar:sym" :subid("90_1275599996.35368") :method .annotate 'line', 3 - new $P326, "ResizablePMCArray" - push $P326, ":PIR{{" - .return ($P326) + new $P330, "ResizablePMCArray" + push $P330, ":PIR{{" + .return ($P330) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash" :subid("91_1275511689.56967") :method +.sub "backslash" :subid("91_1275599996.35368") :method .annotate 'line', 120 - $P332 = self."!protoregex"("backslash") - .return ($P332) + $P336 = self."!protoregex"("backslash") + .return ($P336) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash" :subid("92_1275511689.56967") :method +.sub "!PREFIX__backslash" :subid("92_1275599996.35368") :method .annotate 'line', 120 - $P334 = self."!PREFIX__!protoregex"("backslash") - .return ($P334) + $P338 = self."!PREFIX__!protoregex"("backslash") + .return ($P338) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("93_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("93_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx336_tgt - .local int rx336_pos - .local int rx336_off - .local int rx336_eos - .local int rx336_rep - .local pmc rx336_cur - (rx336_cur, rx336_pos, rx336_tgt) = self."!cursor_start"() - rx336_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx336_cur + .local string rx340_tgt + .local int rx340_pos + .local int rx340_off + .local int rx340_eos + .local int rx340_rep + .local pmc rx340_cur + (rx340_cur, rx340_pos, rx340_tgt) = self."!cursor_start"() + rx340_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx340_cur .local pmc match .lex "$/", match - length rx336_eos, rx336_tgt - gt rx336_pos, rx336_eos, rx336_done - set rx336_off, 0 - lt rx336_pos, 2, rx336_start - sub rx336_off, rx336_pos, 1 - substr rx336_tgt, rx336_tgt, rx336_off - rx336_start: + length rx340_eos, rx340_tgt + gt rx340_pos, rx340_eos, rx340_done + set rx340_off, 0 + lt rx340_pos, 2, rx340_start + sub rx340_off, rx340_pos, 1 + substr rx340_tgt, rx340_tgt, rx340_off + rx340_start: $I10 = self.'from'() - ne $I10, -1, rxscan339_done - goto rxscan339_scan - rxscan339_loop: - ($P10) = rx336_cur."from"() + ne $I10, -1, rxscan343_done + goto rxscan343_scan + rxscan343_loop: + ($P10) = rx340_cur."from"() inc $P10 - set rx336_pos, $P10 - ge rx336_pos, rx336_eos, rxscan339_done - rxscan339_scan: - set_addr $I10, rxscan339_loop - rx336_cur."!mark_push"(0, rx336_pos, $I10) - rxscan339_done: + set rx340_pos, $P10 + ge rx340_pos, rx340_eos, rxscan343_done + rxscan343_scan: + set_addr $I10, rxscan343_loop + rx340_cur."!mark_push"(0, rx340_pos, $I10) + rxscan343_done: .annotate 'line', 121 # rx subcapture "sym" - set_addr $I10, rxcap_340_fail - rx336_cur."!mark_push"(0, rx336_pos, $I10) + set_addr $I10, rxcap_344_fail + rx340_cur."!mark_push"(0, rx340_pos, $I10) # rx enumcharlist negate=0 - ge rx336_pos, rx336_eos, rx336_fail - sub $I10, rx336_pos, rx336_off - substr $S10, rx336_tgt, $I10, 1 + ge rx340_pos, rx340_eos, rx340_fail + sub $I10, rx340_pos, rx340_off + substr $S10, rx340_tgt, $I10, 1 index $I11, "dswnDSWN", $S10 - lt $I11, 0, rx336_fail - inc rx336_pos - set_addr $I10, rxcap_340_fail - ($I12, $I11) = rx336_cur."!mark_peek"($I10) - rx336_cur."!cursor_pos"($I11) - ($P10) = rx336_cur."!cursor_start"() - $P10."!cursor_pass"(rx336_pos, "") - rx336_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, 0, rx340_fail + inc rx340_pos + set_addr $I10, rxcap_344_fail + ($I12, $I11) = rx340_cur."!mark_peek"($I10) + rx340_cur."!cursor_pos"($I11) + ($P10) = rx340_cur."!cursor_start"() + $P10."!cursor_pass"(rx340_pos, "") + rx340_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_340_done - rxcap_340_fail: - goto rx336_fail - rxcap_340_done: + goto rxcap_344_done + rxcap_344_fail: + goto rx340_fail + rxcap_344_done: # rx pass - rx336_cur."!cursor_pass"(rx336_pos, "backslash:sym") - rx336_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx336_pos) - .return (rx336_cur) - rx336_fail: -.annotate 'line', 3 - (rx336_rep, rx336_pos, $I10, $P10) = rx336_cur."!mark_fail"(0) - lt rx336_pos, -1, rx336_done - eq rx336_pos, -1, rx336_fail + rx340_cur."!cursor_pass"(rx340_pos, "backslash:sym") + rx340_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx340_pos) + .return (rx340_cur) + rx340_fail: +.annotate 'line', 3 + (rx340_rep, rx340_pos, $I10, $P10) = rx340_cur."!mark_fail"(0) + lt rx340_pos, -1, rx340_done + eq rx340_pos, -1, rx340_fail jump $I10 - rx336_done: - rx336_cur."!cursor_fail"() - rx336_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx336_cur) + rx340_done: + rx340_cur."!cursor_fail"() + rx340_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx340_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("94_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("94_1275599996.35368") :method .annotate 'line', 3 - new $P338, "ResizablePMCArray" - push $P338, "N" - push $P338, "W" - push $P338, "S" - push $P338, "D" - push $P338, "n" - push $P338, "w" - push $P338, "s" - push $P338, "d" - .return ($P338) + new $P342, "ResizablePMCArray" + push $P342, "N" + push $P342, "W" + push $P342, "S" + push $P342, "D" + push $P342, "n" + push $P342, "w" + push $P342, "s" + push $P342, "d" + .return ($P342) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("95_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("95_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx342_tgt - .local int rx342_pos - .local int rx342_off - .local int rx342_eos - .local int rx342_rep - .local pmc rx342_cur - (rx342_cur, rx342_pos, rx342_tgt) = self."!cursor_start"() - rx342_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx342_cur + .local string rx346_tgt + .local int rx346_pos + .local int rx346_off + .local int rx346_eos + .local int rx346_rep + .local pmc rx346_cur + (rx346_cur, rx346_pos, rx346_tgt) = self."!cursor_start"() + rx346_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx346_cur .local pmc match .lex "$/", match - length rx342_eos, rx342_tgt - gt rx342_pos, rx342_eos, rx342_done - set rx342_off, 0 - lt rx342_pos, 2, rx342_start - sub rx342_off, rx342_pos, 1 - substr rx342_tgt, rx342_tgt, rx342_off - rx342_start: + length rx346_eos, rx346_tgt + gt rx346_pos, rx346_eos, rx346_done + set rx346_off, 0 + lt rx346_pos, 2, rx346_start + sub rx346_off, rx346_pos, 1 + substr rx346_tgt, rx346_tgt, rx346_off + rx346_start: $I10 = self.'from'() - ne $I10, -1, rxscan345_done - goto rxscan345_scan - rxscan345_loop: - ($P10) = rx342_cur."from"() + ne $I10, -1, rxscan349_done + goto rxscan349_scan + rxscan349_loop: + ($P10) = rx346_cur."from"() inc $P10 - set rx342_pos, $P10 - ge rx342_pos, rx342_eos, rxscan345_done - rxscan345_scan: - set_addr $I10, rxscan345_loop - rx342_cur."!mark_push"(0, rx342_pos, $I10) - rxscan345_done: + set rx346_pos, $P10 + ge rx346_pos, rx346_eos, rxscan349_done + rxscan349_scan: + set_addr $I10, rxscan349_loop + rx346_cur."!mark_push"(0, rx346_pos, $I10) + rxscan349_done: .annotate 'line', 122 # rx subcapture "sym" - set_addr $I10, rxcap_346_fail - rx342_cur."!mark_push"(0, rx342_pos, $I10) + set_addr $I10, rxcap_350_fail + rx346_cur."!mark_push"(0, rx346_pos, $I10) # rx enumcharlist negate=0 - ge rx342_pos, rx342_eos, rx342_fail - sub $I10, rx342_pos, rx342_off - substr $S10, rx342_tgt, $I10, 1 + ge rx346_pos, rx346_eos, rx346_fail + sub $I10, rx346_pos, rx346_off + substr $S10, rx346_tgt, $I10, 1 index $I11, "bB", $S10 - lt $I11, 0, rx342_fail - inc rx342_pos - set_addr $I10, rxcap_346_fail - ($I12, $I11) = rx342_cur."!mark_peek"($I10) - rx342_cur."!cursor_pos"($I11) - ($P10) = rx342_cur."!cursor_start"() - $P10."!cursor_pass"(rx342_pos, "") - rx342_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, 0, rx346_fail + inc rx346_pos + set_addr $I10, rxcap_350_fail + ($I12, $I11) = rx346_cur."!mark_peek"($I10) + rx346_cur."!cursor_pos"($I11) + ($P10) = rx346_cur."!cursor_start"() + $P10."!cursor_pass"(rx346_pos, "") + rx346_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_346_done - rxcap_346_fail: - goto rx342_fail - rxcap_346_done: + goto rxcap_350_done + rxcap_350_fail: + goto rx346_fail + rxcap_350_done: # rx pass - rx342_cur."!cursor_pass"(rx342_pos, "backslash:sym") - rx342_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx342_pos) - .return (rx342_cur) - rx342_fail: -.annotate 'line', 3 - (rx342_rep, rx342_pos, $I10, $P10) = rx342_cur."!mark_fail"(0) - lt rx342_pos, -1, rx342_done - eq rx342_pos, -1, rx342_fail + rx346_cur."!cursor_pass"(rx346_pos, "backslash:sym") + rx346_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx346_pos) + .return (rx346_cur) + rx346_fail: +.annotate 'line', 3 + (rx346_rep, rx346_pos, $I10, $P10) = rx346_cur."!mark_fail"(0) + lt rx346_pos, -1, rx346_done + eq rx346_pos, -1, rx346_fail jump $I10 - rx342_done: - rx342_cur."!cursor_fail"() - rx342_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx342_cur) + rx346_done: + rx346_cur."!cursor_fail"() + rx346_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx346_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("96_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("96_1275599996.35368") :method .annotate 'line', 3 - new $P344, "ResizablePMCArray" - push $P344, "B" - push $P344, "b" - .return ($P344) + new $P348, "ResizablePMCArray" + push $P348, "B" + push $P348, "b" + .return ($P348) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("97_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("97_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx348_tgt - .local int rx348_pos - .local int rx348_off - .local int rx348_eos - .local int rx348_rep - .local pmc rx348_cur - (rx348_cur, rx348_pos, rx348_tgt) = self."!cursor_start"() - rx348_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx348_cur + .local string rx352_tgt + .local int rx352_pos + .local int rx352_off + .local int rx352_eos + .local int rx352_rep + .local pmc rx352_cur + (rx352_cur, rx352_pos, rx352_tgt) = self."!cursor_start"() + rx352_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx352_cur .local pmc match .lex "$/", match - length rx348_eos, rx348_tgt - gt rx348_pos, rx348_eos, rx348_done - set rx348_off, 0 - lt rx348_pos, 2, rx348_start - sub rx348_off, rx348_pos, 1 - substr rx348_tgt, rx348_tgt, rx348_off - rx348_start: + length rx352_eos, rx352_tgt + gt rx352_pos, rx352_eos, rx352_done + set rx352_off, 0 + lt rx352_pos, 2, rx352_start + sub rx352_off, rx352_pos, 1 + substr rx352_tgt, rx352_tgt, rx352_off + rx352_start: $I10 = self.'from'() - ne $I10, -1, rxscan351_done - goto rxscan351_scan - rxscan351_loop: - ($P10) = rx348_cur."from"() + ne $I10, -1, rxscan355_done + goto rxscan355_scan + rxscan355_loop: + ($P10) = rx352_cur."from"() inc $P10 - set rx348_pos, $P10 - ge rx348_pos, rx348_eos, rxscan351_done - rxscan351_scan: - set_addr $I10, rxscan351_loop - rx348_cur."!mark_push"(0, rx348_pos, $I10) - rxscan351_done: + set rx352_pos, $P10 + ge rx352_pos, rx352_eos, rxscan355_done + rxscan355_scan: + set_addr $I10, rxscan355_loop + rx352_cur."!mark_push"(0, rx352_pos, $I10) + rxscan355_done: .annotate 'line', 123 # rx subcapture "sym" - set_addr $I10, rxcap_352_fail - rx348_cur."!mark_push"(0, rx348_pos, $I10) + set_addr $I10, rxcap_356_fail + rx352_cur."!mark_push"(0, rx352_pos, $I10) # rx enumcharlist negate=0 - ge rx348_pos, rx348_eos, rx348_fail - sub $I10, rx348_pos, rx348_off - substr $S10, rx348_tgt, $I10, 1 + ge rx352_pos, rx352_eos, rx352_fail + sub $I10, rx352_pos, rx352_off + substr $S10, rx352_tgt, $I10, 1 index $I11, "eE", $S10 - lt $I11, 0, rx348_fail - inc rx348_pos - set_addr $I10, rxcap_352_fail - ($I12, $I11) = rx348_cur."!mark_peek"($I10) - rx348_cur."!cursor_pos"($I11) - ($P10) = rx348_cur."!cursor_start"() - $P10."!cursor_pass"(rx348_pos, "") - rx348_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, 0, rx352_fail + inc rx352_pos + set_addr $I10, rxcap_356_fail + ($I12, $I11) = rx352_cur."!mark_peek"($I10) + rx352_cur."!cursor_pos"($I11) + ($P10) = rx352_cur."!cursor_start"() + $P10."!cursor_pass"(rx352_pos, "") + rx352_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_352_done - rxcap_352_fail: - goto rx348_fail - rxcap_352_done: + goto rxcap_356_done + rxcap_356_fail: + goto rx352_fail + rxcap_356_done: # rx pass - rx348_cur."!cursor_pass"(rx348_pos, "backslash:sym") - rx348_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx348_pos) - .return (rx348_cur) - rx348_fail: -.annotate 'line', 3 - (rx348_rep, rx348_pos, $I10, $P10) = rx348_cur."!mark_fail"(0) - lt rx348_pos, -1, rx348_done - eq rx348_pos, -1, rx348_fail + rx352_cur."!cursor_pass"(rx352_pos, "backslash:sym") + rx352_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx352_pos) + .return (rx352_cur) + rx352_fail: +.annotate 'line', 3 + (rx352_rep, rx352_pos, $I10, $P10) = rx352_cur."!mark_fail"(0) + lt rx352_pos, -1, rx352_done + eq rx352_pos, -1, rx352_fail jump $I10 - rx348_done: - rx348_cur."!cursor_fail"() - rx348_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx348_cur) + rx352_done: + rx352_cur."!cursor_fail"() + rx352_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx352_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("98_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("98_1275599996.35368") :method .annotate 'line', 3 - new $P350, "ResizablePMCArray" - push $P350, "E" - push $P350, "e" - .return ($P350) + new $P354, "ResizablePMCArray" + push $P354, "E" + push $P354, "e" + .return ($P354) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("99_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("99_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx354_tgt - .local int rx354_pos - .local int rx354_off - .local int rx354_eos - .local int rx354_rep - .local pmc rx354_cur - (rx354_cur, rx354_pos, rx354_tgt) = self."!cursor_start"() - rx354_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx354_cur + .local string rx358_tgt + .local int rx358_pos + .local int rx358_off + .local int rx358_eos + .local int rx358_rep + .local pmc rx358_cur + (rx358_cur, rx358_pos, rx358_tgt) = self."!cursor_start"() + rx358_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx358_cur .local pmc match .lex "$/", match - length rx354_eos, rx354_tgt - gt rx354_pos, rx354_eos, rx354_done - set rx354_off, 0 - lt rx354_pos, 2, rx354_start - sub rx354_off, rx354_pos, 1 - substr rx354_tgt, rx354_tgt, rx354_off - rx354_start: + length rx358_eos, rx358_tgt + gt rx358_pos, rx358_eos, rx358_done + set rx358_off, 0 + lt rx358_pos, 2, rx358_start + sub rx358_off, rx358_pos, 1 + substr rx358_tgt, rx358_tgt, rx358_off + rx358_start: $I10 = self.'from'() - ne $I10, -1, rxscan357_done - goto rxscan357_scan - rxscan357_loop: - ($P10) = rx354_cur."from"() + ne $I10, -1, rxscan361_done + goto rxscan361_scan + rxscan361_loop: + ($P10) = rx358_cur."from"() inc $P10 - set rx354_pos, $P10 - ge rx354_pos, rx354_eos, rxscan357_done - rxscan357_scan: - set_addr $I10, rxscan357_loop - rx354_cur."!mark_push"(0, rx354_pos, $I10) - rxscan357_done: + set rx358_pos, $P10 + ge rx358_pos, rx358_eos, rxscan361_done + rxscan361_scan: + set_addr $I10, rxscan361_loop + rx358_cur."!mark_push"(0, rx358_pos, $I10) + rxscan361_done: .annotate 'line', 124 # rx subcapture "sym" - set_addr $I10, rxcap_358_fail - rx354_cur."!mark_push"(0, rx354_pos, $I10) + set_addr $I10, rxcap_362_fail + rx358_cur."!mark_push"(0, rx358_pos, $I10) # rx enumcharlist negate=0 - ge rx354_pos, rx354_eos, rx354_fail - sub $I10, rx354_pos, rx354_off - substr $S10, rx354_tgt, $I10, 1 + ge rx358_pos, rx358_eos, rx358_fail + sub $I10, rx358_pos, rx358_off + substr $S10, rx358_tgt, $I10, 1 index $I11, "fF", $S10 - lt $I11, 0, rx354_fail - inc rx354_pos - set_addr $I10, rxcap_358_fail - ($I12, $I11) = rx354_cur."!mark_peek"($I10) - rx354_cur."!cursor_pos"($I11) - ($P10) = rx354_cur."!cursor_start"() - $P10."!cursor_pass"(rx354_pos, "") - rx354_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, 0, rx358_fail + inc rx358_pos + set_addr $I10, rxcap_362_fail + ($I12, $I11) = rx358_cur."!mark_peek"($I10) + rx358_cur."!cursor_pos"($I11) + ($P10) = rx358_cur."!cursor_start"() + $P10."!cursor_pass"(rx358_pos, "") + rx358_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_358_done - rxcap_358_fail: - goto rx354_fail - rxcap_358_done: + goto rxcap_362_done + rxcap_362_fail: + goto rx358_fail + rxcap_362_done: # rx pass - rx354_cur."!cursor_pass"(rx354_pos, "backslash:sym") - rx354_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx354_pos) - .return (rx354_cur) - rx354_fail: -.annotate 'line', 3 - (rx354_rep, rx354_pos, $I10, $P10) = rx354_cur."!mark_fail"(0) - lt rx354_pos, -1, rx354_done - eq rx354_pos, -1, rx354_fail + rx358_cur."!cursor_pass"(rx358_pos, "backslash:sym") + rx358_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx358_pos) + .return (rx358_cur) + rx358_fail: +.annotate 'line', 3 + (rx358_rep, rx358_pos, $I10, $P10) = rx358_cur."!mark_fail"(0) + lt rx358_pos, -1, rx358_done + eq rx358_pos, -1, rx358_fail jump $I10 - rx354_done: - rx354_cur."!cursor_fail"() - rx354_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx354_cur) + rx358_done: + rx358_cur."!cursor_fail"() + rx358_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx358_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("100_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("100_1275599996.35368") :method .annotate 'line', 3 - new $P356, "ResizablePMCArray" - push $P356, "F" - push $P356, "f" - .return ($P356) + new $P360, "ResizablePMCArray" + push $P360, "F" + push $P360, "f" + .return ($P360) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("101_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("101_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx360_tgt - .local int rx360_pos - .local int rx360_off - .local int rx360_eos - .local int rx360_rep - .local pmc rx360_cur - (rx360_cur, rx360_pos, rx360_tgt) = self."!cursor_start"() - rx360_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx360_cur + .local string rx364_tgt + .local int rx364_pos + .local int rx364_off + .local int rx364_eos + .local int rx364_rep + .local pmc rx364_cur + (rx364_cur, rx364_pos, rx364_tgt) = self."!cursor_start"() + rx364_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx364_cur .local pmc match .lex "$/", match - length rx360_eos, rx360_tgt - gt rx360_pos, rx360_eos, rx360_done - set rx360_off, 0 - lt rx360_pos, 2, rx360_start - sub rx360_off, rx360_pos, 1 - substr rx360_tgt, rx360_tgt, rx360_off - rx360_start: + length rx364_eos, rx364_tgt + gt rx364_pos, rx364_eos, rx364_done + set rx364_off, 0 + lt rx364_pos, 2, rx364_start + sub rx364_off, rx364_pos, 1 + substr rx364_tgt, rx364_tgt, rx364_off + rx364_start: $I10 = self.'from'() - ne $I10, -1, rxscan363_done - goto rxscan363_scan - rxscan363_loop: - ($P10) = rx360_cur."from"() + ne $I10, -1, rxscan367_done + goto rxscan367_scan + rxscan367_loop: + ($P10) = rx364_cur."from"() inc $P10 - set rx360_pos, $P10 - ge rx360_pos, rx360_eos, rxscan363_done - rxscan363_scan: - set_addr $I10, rxscan363_loop - rx360_cur."!mark_push"(0, rx360_pos, $I10) - rxscan363_done: + set rx364_pos, $P10 + ge rx364_pos, rx364_eos, rxscan367_done + rxscan367_scan: + set_addr $I10, rxscan367_loop + rx364_cur."!mark_push"(0, rx364_pos, $I10) + rxscan367_done: .annotate 'line', 125 # rx subcapture "sym" - set_addr $I10, rxcap_364_fail - rx360_cur."!mark_push"(0, rx360_pos, $I10) + set_addr $I10, rxcap_368_fail + rx364_cur."!mark_push"(0, rx364_pos, $I10) # rx enumcharlist negate=0 - ge rx360_pos, rx360_eos, rx360_fail - sub $I10, rx360_pos, rx360_off - substr $S10, rx360_tgt, $I10, 1 + ge rx364_pos, rx364_eos, rx364_fail + sub $I10, rx364_pos, rx364_off + substr $S10, rx364_tgt, $I10, 1 index $I11, "hH", $S10 - lt $I11, 0, rx360_fail - inc rx360_pos - set_addr $I10, rxcap_364_fail - ($I12, $I11) = rx360_cur."!mark_peek"($I10) - rx360_cur."!cursor_pos"($I11) - ($P10) = rx360_cur."!cursor_start"() - $P10."!cursor_pass"(rx360_pos, "") - rx360_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, 0, rx364_fail + inc rx364_pos + set_addr $I10, rxcap_368_fail + ($I12, $I11) = rx364_cur."!mark_peek"($I10) + rx364_cur."!cursor_pos"($I11) + ($P10) = rx364_cur."!cursor_start"() + $P10."!cursor_pass"(rx364_pos, "") + rx364_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_364_done - rxcap_364_fail: - goto rx360_fail - rxcap_364_done: + goto rxcap_368_done + rxcap_368_fail: + goto rx364_fail + rxcap_368_done: # rx pass - rx360_cur."!cursor_pass"(rx360_pos, "backslash:sym") - rx360_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx360_pos) - .return (rx360_cur) - rx360_fail: -.annotate 'line', 3 - (rx360_rep, rx360_pos, $I10, $P10) = rx360_cur."!mark_fail"(0) - lt rx360_pos, -1, rx360_done - eq rx360_pos, -1, rx360_fail + rx364_cur."!cursor_pass"(rx364_pos, "backslash:sym") + rx364_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx364_pos) + .return (rx364_cur) + rx364_fail: +.annotate 'line', 3 + (rx364_rep, rx364_pos, $I10, $P10) = rx364_cur."!mark_fail"(0) + lt rx364_pos, -1, rx364_done + eq rx364_pos, -1, rx364_fail jump $I10 - rx360_done: - rx360_cur."!cursor_fail"() - rx360_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx360_cur) + rx364_done: + rx364_cur."!cursor_fail"() + rx364_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx364_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("102_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("102_1275599996.35368") :method .annotate 'line', 3 - new $P362, "ResizablePMCArray" - push $P362, "H" - push $P362, "h" - .return ($P362) + new $P366, "ResizablePMCArray" + push $P366, "H" + push $P366, "h" + .return ($P366) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("103_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("103_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx366_tgt - .local int rx366_pos - .local int rx366_off - .local int rx366_eos - .local int rx366_rep - .local pmc rx366_cur - (rx366_cur, rx366_pos, rx366_tgt) = self."!cursor_start"() - rx366_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx366_cur + .local string rx370_tgt + .local int rx370_pos + .local int rx370_off + .local int rx370_eos + .local int rx370_rep + .local pmc rx370_cur + (rx370_cur, rx370_pos, rx370_tgt) = self."!cursor_start"() + rx370_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx370_cur .local pmc match .lex "$/", match - length rx366_eos, rx366_tgt - gt rx366_pos, rx366_eos, rx366_done - set rx366_off, 0 - lt rx366_pos, 2, rx366_start - sub rx366_off, rx366_pos, 1 - substr rx366_tgt, rx366_tgt, rx366_off - rx366_start: + length rx370_eos, rx370_tgt + gt rx370_pos, rx370_eos, rx370_done + set rx370_off, 0 + lt rx370_pos, 2, rx370_start + sub rx370_off, rx370_pos, 1 + substr rx370_tgt, rx370_tgt, rx370_off + rx370_start: $I10 = self.'from'() - ne $I10, -1, rxscan369_done - goto rxscan369_scan - rxscan369_loop: - ($P10) = rx366_cur."from"() + ne $I10, -1, rxscan373_done + goto rxscan373_scan + rxscan373_loop: + ($P10) = rx370_cur."from"() inc $P10 - set rx366_pos, $P10 - ge rx366_pos, rx366_eos, rxscan369_done - rxscan369_scan: - set_addr $I10, rxscan369_loop - rx366_cur."!mark_push"(0, rx366_pos, $I10) - rxscan369_done: + set rx370_pos, $P10 + ge rx370_pos, rx370_eos, rxscan373_done + rxscan373_scan: + set_addr $I10, rxscan373_loop + rx370_cur."!mark_push"(0, rx370_pos, $I10) + rxscan373_done: .annotate 'line', 126 # rx subcapture "sym" - set_addr $I10, rxcap_370_fail - rx366_cur."!mark_push"(0, rx366_pos, $I10) + set_addr $I10, rxcap_374_fail + rx370_cur."!mark_push"(0, rx370_pos, $I10) # rx enumcharlist negate=0 - ge rx366_pos, rx366_eos, rx366_fail - sub $I10, rx366_pos, rx366_off - substr $S10, rx366_tgt, $I10, 1 + ge rx370_pos, rx370_eos, rx370_fail + sub $I10, rx370_pos, rx370_off + substr $S10, rx370_tgt, $I10, 1 index $I11, "rR", $S10 - lt $I11, 0, rx366_fail - inc rx366_pos - set_addr $I10, rxcap_370_fail - ($I12, $I11) = rx366_cur."!mark_peek"($I10) - rx366_cur."!cursor_pos"($I11) - ($P10) = rx366_cur."!cursor_start"() - $P10."!cursor_pass"(rx366_pos, "") - rx366_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, 0, rx370_fail + inc rx370_pos + set_addr $I10, rxcap_374_fail + ($I12, $I11) = rx370_cur."!mark_peek"($I10) + rx370_cur."!cursor_pos"($I11) + ($P10) = rx370_cur."!cursor_start"() + $P10."!cursor_pass"(rx370_pos, "") + rx370_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_370_done - rxcap_370_fail: - goto rx366_fail - rxcap_370_done: + goto rxcap_374_done + rxcap_374_fail: + goto rx370_fail + rxcap_374_done: # rx pass - rx366_cur."!cursor_pass"(rx366_pos, "backslash:sym") - rx366_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx366_pos) - .return (rx366_cur) - rx366_fail: -.annotate 'line', 3 - (rx366_rep, rx366_pos, $I10, $P10) = rx366_cur."!mark_fail"(0) - lt rx366_pos, -1, rx366_done - eq rx366_pos, -1, rx366_fail + rx370_cur."!cursor_pass"(rx370_pos, "backslash:sym") + rx370_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx370_pos) + .return (rx370_cur) + rx370_fail: +.annotate 'line', 3 + (rx370_rep, rx370_pos, $I10, $P10) = rx370_cur."!mark_fail"(0) + lt rx370_pos, -1, rx370_done + eq rx370_pos, -1, rx370_fail jump $I10 - rx366_done: - rx366_cur."!cursor_fail"() - rx366_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx366_cur) + rx370_done: + rx370_cur."!cursor_fail"() + rx370_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx370_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("104_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("104_1275599996.35368") :method .annotate 'line', 3 - new $P368, "ResizablePMCArray" - push $P368, "R" - push $P368, "r" - .return ($P368) + new $P372, "ResizablePMCArray" + push $P372, "R" + push $P372, "r" + .return ($P372) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("105_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("105_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx372_tgt - .local int rx372_pos - .local int rx372_off - .local int rx372_eos - .local int rx372_rep - .local pmc rx372_cur - (rx372_cur, rx372_pos, rx372_tgt) = self."!cursor_start"() - rx372_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx372_cur + .local string rx376_tgt + .local int rx376_pos + .local int rx376_off + .local int rx376_eos + .local int rx376_rep + .local pmc rx376_cur + (rx376_cur, rx376_pos, rx376_tgt) = self."!cursor_start"() + rx376_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx376_cur .local pmc match .lex "$/", match - length rx372_eos, rx372_tgt - gt rx372_pos, rx372_eos, rx372_done - set rx372_off, 0 - lt rx372_pos, 2, rx372_start - sub rx372_off, rx372_pos, 1 - substr rx372_tgt, rx372_tgt, rx372_off - rx372_start: + length rx376_eos, rx376_tgt + gt rx376_pos, rx376_eos, rx376_done + set rx376_off, 0 + lt rx376_pos, 2, rx376_start + sub rx376_off, rx376_pos, 1 + substr rx376_tgt, rx376_tgt, rx376_off + rx376_start: $I10 = self.'from'() - ne $I10, -1, rxscan375_done - goto rxscan375_scan - rxscan375_loop: - ($P10) = rx372_cur."from"() + ne $I10, -1, rxscan379_done + goto rxscan379_scan + rxscan379_loop: + ($P10) = rx376_cur."from"() inc $P10 - set rx372_pos, $P10 - ge rx372_pos, rx372_eos, rxscan375_done - rxscan375_scan: - set_addr $I10, rxscan375_loop - rx372_cur."!mark_push"(0, rx372_pos, $I10) - rxscan375_done: + set rx376_pos, $P10 + ge rx376_pos, rx376_eos, rxscan379_done + rxscan379_scan: + set_addr $I10, rxscan379_loop + rx376_cur."!mark_push"(0, rx376_pos, $I10) + rxscan379_done: .annotate 'line', 127 # rx subcapture "sym" - set_addr $I10, rxcap_376_fail - rx372_cur."!mark_push"(0, rx372_pos, $I10) + set_addr $I10, rxcap_380_fail + rx376_cur."!mark_push"(0, rx376_pos, $I10) # rx enumcharlist negate=0 - ge rx372_pos, rx372_eos, rx372_fail - sub $I10, rx372_pos, rx372_off - substr $S10, rx372_tgt, $I10, 1 + ge rx376_pos, rx376_eos, rx376_fail + sub $I10, rx376_pos, rx376_off + substr $S10, rx376_tgt, $I10, 1 index $I11, "tT", $S10 - lt $I11, 0, rx372_fail - inc rx372_pos - set_addr $I10, rxcap_376_fail - ($I12, $I11) = rx372_cur."!mark_peek"($I10) - rx372_cur."!cursor_pos"($I11) - ($P10) = rx372_cur."!cursor_start"() - $P10."!cursor_pass"(rx372_pos, "") - rx372_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, 0, rx376_fail + inc rx376_pos + set_addr $I10, rxcap_380_fail + ($I12, $I11) = rx376_cur."!mark_peek"($I10) + rx376_cur."!cursor_pos"($I11) + ($P10) = rx376_cur."!cursor_start"() + $P10."!cursor_pass"(rx376_pos, "") + rx376_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_376_done - rxcap_376_fail: - goto rx372_fail - rxcap_376_done: + goto rxcap_380_done + rxcap_380_fail: + goto rx376_fail + rxcap_380_done: # rx pass - rx372_cur."!cursor_pass"(rx372_pos, "backslash:sym") - rx372_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx372_pos) - .return (rx372_cur) - rx372_fail: -.annotate 'line', 3 - (rx372_rep, rx372_pos, $I10, $P10) = rx372_cur."!mark_fail"(0) - lt rx372_pos, -1, rx372_done - eq rx372_pos, -1, rx372_fail + rx376_cur."!cursor_pass"(rx376_pos, "backslash:sym") + rx376_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx376_pos) + .return (rx376_cur) + rx376_fail: +.annotate 'line', 3 + (rx376_rep, rx376_pos, $I10, $P10) = rx376_cur."!mark_fail"(0) + lt rx376_pos, -1, rx376_done + eq rx376_pos, -1, rx376_fail jump $I10 - rx372_done: - rx372_cur."!cursor_fail"() - rx372_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx372_cur) + rx376_done: + rx376_cur."!cursor_fail"() + rx376_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx376_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("106_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("106_1275599996.35368") :method .annotate 'line', 3 - new $P374, "ResizablePMCArray" - push $P374, "T" - push $P374, "t" - .return ($P374) + new $P378, "ResizablePMCArray" + push $P378, "T" + push $P378, "t" + .return ($P378) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("107_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("107_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx378_tgt - .local int rx378_pos - .local int rx378_off - .local int rx378_eos - .local int rx378_rep - .local pmc rx378_cur - (rx378_cur, rx378_pos, rx378_tgt) = self."!cursor_start"() - rx378_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx378_cur + .local string rx382_tgt + .local int rx382_pos + .local int rx382_off + .local int rx382_eos + .local int rx382_rep + .local pmc rx382_cur + (rx382_cur, rx382_pos, rx382_tgt) = self."!cursor_start"() + rx382_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx382_cur .local pmc match .lex "$/", match - length rx378_eos, rx378_tgt - gt rx378_pos, rx378_eos, rx378_done - set rx378_off, 0 - lt rx378_pos, 2, rx378_start - sub rx378_off, rx378_pos, 1 - substr rx378_tgt, rx378_tgt, rx378_off - rx378_start: + length rx382_eos, rx382_tgt + gt rx382_pos, rx382_eos, rx382_done + set rx382_off, 0 + lt rx382_pos, 2, rx382_start + sub rx382_off, rx382_pos, 1 + substr rx382_tgt, rx382_tgt, rx382_off + rx382_start: $I10 = self.'from'() - ne $I10, -1, rxscan381_done - goto rxscan381_scan - rxscan381_loop: - ($P10) = rx378_cur."from"() + ne $I10, -1, rxscan385_done + goto rxscan385_scan + rxscan385_loop: + ($P10) = rx382_cur."from"() inc $P10 - set rx378_pos, $P10 - ge rx378_pos, rx378_eos, rxscan381_done - rxscan381_scan: - set_addr $I10, rxscan381_loop - rx378_cur."!mark_push"(0, rx378_pos, $I10) - rxscan381_done: + set rx382_pos, $P10 + ge rx382_pos, rx382_eos, rxscan385_done + rxscan385_scan: + set_addr $I10, rxscan385_loop + rx382_cur."!mark_push"(0, rx382_pos, $I10) + rxscan385_done: .annotate 'line', 128 # rx subcapture "sym" - set_addr $I10, rxcap_382_fail - rx378_cur."!mark_push"(0, rx378_pos, $I10) + set_addr $I10, rxcap_386_fail + rx382_cur."!mark_push"(0, rx382_pos, $I10) # rx enumcharlist negate=0 - ge rx378_pos, rx378_eos, rx378_fail - sub $I10, rx378_pos, rx378_off - substr $S10, rx378_tgt, $I10, 1 + ge rx382_pos, rx382_eos, rx382_fail + sub $I10, rx382_pos, rx382_off + substr $S10, rx382_tgt, $I10, 1 index $I11, "vV", $S10 - lt $I11, 0, rx378_fail - inc rx378_pos - set_addr $I10, rxcap_382_fail - ($I12, $I11) = rx378_cur."!mark_peek"($I10) - rx378_cur."!cursor_pos"($I11) - ($P10) = rx378_cur."!cursor_start"() - $P10."!cursor_pass"(rx378_pos, "") - rx378_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, 0, rx382_fail + inc rx382_pos + set_addr $I10, rxcap_386_fail + ($I12, $I11) = rx382_cur."!mark_peek"($I10) + rx382_cur."!cursor_pos"($I11) + ($P10) = rx382_cur."!cursor_start"() + $P10."!cursor_pass"(rx382_pos, "") + rx382_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_382_done - rxcap_382_fail: - goto rx378_fail - rxcap_382_done: + goto rxcap_386_done + rxcap_386_fail: + goto rx382_fail + rxcap_386_done: # rx pass - rx378_cur."!cursor_pass"(rx378_pos, "backslash:sym") - rx378_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx378_pos) - .return (rx378_cur) - rx378_fail: -.annotate 'line', 3 - (rx378_rep, rx378_pos, $I10, $P10) = rx378_cur."!mark_fail"(0) - lt rx378_pos, -1, rx378_done - eq rx378_pos, -1, rx378_fail + rx382_cur."!cursor_pass"(rx382_pos, "backslash:sym") + rx382_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx382_pos) + .return (rx382_cur) + rx382_fail: +.annotate 'line', 3 + (rx382_rep, rx382_pos, $I10, $P10) = rx382_cur."!mark_fail"(0) + lt rx382_pos, -1, rx382_done + eq rx382_pos, -1, rx382_fail jump $I10 - rx378_done: - rx378_cur."!cursor_fail"() - rx378_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx378_cur) + rx382_done: + rx382_cur."!cursor_fail"() + rx382_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx382_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("108_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("108_1275599996.35368") :method .annotate 'line', 3 - new $P380, "ResizablePMCArray" - push $P380, "V" - push $P380, "v" - .return ($P380) + new $P384, "ResizablePMCArray" + push $P384, "V" + push $P384, "v" + .return ($P384) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("109_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("109_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx384_tgt - .local int rx384_pos - .local int rx384_off - .local int rx384_eos - .local int rx384_rep - .local pmc rx384_cur - (rx384_cur, rx384_pos, rx384_tgt) = self."!cursor_start"() - rx384_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx384_cur + .local string rx388_tgt + .local int rx388_pos + .local int rx388_off + .local int rx388_eos + .local int rx388_rep + .local pmc rx388_cur + (rx388_cur, rx388_pos, rx388_tgt) = self."!cursor_start"() + rx388_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx388_cur .local pmc match .lex "$/", match - length rx384_eos, rx384_tgt - gt rx384_pos, rx384_eos, rx384_done - set rx384_off, 0 - lt rx384_pos, 2, rx384_start - sub rx384_off, rx384_pos, 1 - substr rx384_tgt, rx384_tgt, rx384_off - rx384_start: + length rx388_eos, rx388_tgt + gt rx388_pos, rx388_eos, rx388_done + set rx388_off, 0 + lt rx388_pos, 2, rx388_start + sub rx388_off, rx388_pos, 1 + substr rx388_tgt, rx388_tgt, rx388_off + rx388_start: $I10 = self.'from'() - ne $I10, -1, rxscan391_done - goto rxscan391_scan - rxscan391_loop: - ($P10) = rx384_cur."from"() + ne $I10, -1, rxscan395_done + goto rxscan395_scan + rxscan395_loop: + ($P10) = rx388_cur."from"() inc $P10 - set rx384_pos, $P10 - ge rx384_pos, rx384_eos, rxscan391_done - rxscan391_scan: - set_addr $I10, rxscan391_loop - rx384_cur."!mark_push"(0, rx384_pos, $I10) - rxscan391_done: + set rx388_pos, $P10 + ge rx388_pos, rx388_eos, rxscan395_done + rxscan395_scan: + set_addr $I10, rxscan395_loop + rx388_cur."!mark_push"(0, rx388_pos, $I10) + rxscan395_done: .annotate 'line', 129 # rx subcapture "sym" - set_addr $I10, rxcap_392_fail - rx384_cur."!mark_push"(0, rx384_pos, $I10) + set_addr $I10, rxcap_396_fail + rx388_cur."!mark_push"(0, rx388_pos, $I10) # rx enumcharlist negate=0 - ge rx384_pos, rx384_eos, rx384_fail - sub $I10, rx384_pos, rx384_off - substr $S10, rx384_tgt, $I10, 1 + ge rx388_pos, rx388_eos, rx388_fail + sub $I10, rx388_pos, rx388_off + substr $S10, rx388_tgt, $I10, 1 index $I11, "oO", $S10 - lt $I11, 0, rx384_fail - inc rx384_pos - set_addr $I10, rxcap_392_fail - ($I12, $I11) = rx384_cur."!mark_peek"($I10) - rx384_cur."!cursor_pos"($I11) - ($P10) = rx384_cur."!cursor_start"() - $P10."!cursor_pass"(rx384_pos, "") - rx384_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, 0, rx388_fail + inc rx388_pos + set_addr $I10, rxcap_396_fail + ($I12, $I11) = rx388_cur."!mark_peek"($I10) + rx388_cur."!cursor_pos"($I11) + ($P10) = rx388_cur."!cursor_start"() + $P10."!cursor_pass"(rx388_pos, "") + rx388_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_392_done - rxcap_392_fail: - goto rx384_fail - rxcap_392_done: - alt393_0: - set_addr $I10, alt393_1 - rx384_cur."!mark_push"(0, rx384_pos, $I10) + goto rxcap_396_done + rxcap_396_fail: + goto rx388_fail + rxcap_396_done: + alt397_0: + set_addr $I10, alt397_1 + rx388_cur."!mark_push"(0, rx388_pos, $I10) # rx subrule "octint" subtype=capture negate= - rx384_cur."!cursor_pos"(rx384_pos) - $P10 = rx384_cur."octint"() - unless $P10, rx384_fail - rx384_cur."!mark_push"(0, -1, 0, $P10) + rx388_cur."!cursor_pos"(rx388_pos) + $P10 = rx388_cur."octint"() + unless $P10, rx388_fail + rx388_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("octint") - rx384_pos = $P10."pos"() - goto alt393_end - alt393_1: + rx388_pos = $P10."pos"() + goto alt397_end + alt397_1: # rx literal "[" - add $I11, rx384_pos, 1 - gt $I11, rx384_eos, rx384_fail - sub $I11, rx384_pos, rx384_off - substr $S10, rx384_tgt, $I11, 1 - ne $S10, "[", rx384_fail - add rx384_pos, 1 + add $I11, rx388_pos, 1 + gt $I11, rx388_eos, rx388_fail + sub $I11, rx388_pos, rx388_off + substr $S10, rx388_tgt, $I11, 1 + ne $S10, "[", rx388_fail + add rx388_pos, 1 # rx subrule "octints" subtype=capture negate= - rx384_cur."!cursor_pos"(rx384_pos) - $P10 = rx384_cur."octints"() - unless $P10, rx384_fail - rx384_cur."!mark_push"(0, -1, 0, $P10) + rx388_cur."!cursor_pos"(rx388_pos) + $P10 = rx388_cur."octints"() + unless $P10, rx388_fail + rx388_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("octints") - rx384_pos = $P10."pos"() + rx388_pos = $P10."pos"() # rx literal "]" - add $I11, rx384_pos, 1 - gt $I11, rx384_eos, rx384_fail - sub $I11, rx384_pos, rx384_off - substr $S10, rx384_tgt, $I11, 1 - ne $S10, "]", rx384_fail - add rx384_pos, 1 - alt393_end: + add $I11, rx388_pos, 1 + gt $I11, rx388_eos, rx388_fail + sub $I11, rx388_pos, rx388_off + substr $S10, rx388_tgt, $I11, 1 + ne $S10, "]", rx388_fail + add rx388_pos, 1 + alt397_end: # rx pass - rx384_cur."!cursor_pass"(rx384_pos, "backslash:sym") - rx384_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx384_pos) - .return (rx384_cur) - rx384_fail: -.annotate 'line', 3 - (rx384_rep, rx384_pos, $I10, $P10) = rx384_cur."!mark_fail"(0) - lt rx384_pos, -1, rx384_done - eq rx384_pos, -1, rx384_fail + rx388_cur."!cursor_pass"(rx388_pos, "backslash:sym") + rx388_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx388_pos) + .return (rx388_cur) + rx388_fail: +.annotate 'line', 3 + (rx388_rep, rx388_pos, $I10, $P10) = rx388_cur."!mark_fail"(0) + lt rx388_pos, -1, rx388_done + eq rx388_pos, -1, rx388_fail jump $I10 - rx384_done: - rx384_cur."!cursor_fail"() - rx384_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx384_cur) + rx388_done: + rx388_cur."!cursor_fail"() + rx388_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx388_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("110_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("110_1275599996.35368") :method .annotate 'line', 3 - $P386 = self."!PREFIX__!subrule"("octints", "O[") - $P387 = self."!PREFIX__!subrule"("octint", "O") - $P388 = self."!PREFIX__!subrule"("octints", "o[") - $P389 = self."!PREFIX__!subrule"("octint", "o") - new $P390, "ResizablePMCArray" - push $P390, $P386 - push $P390, $P387 - push $P390, $P388 - push $P390, $P389 - .return ($P390) + $P390 = self."!PREFIX__!subrule"("octints", "O[") + $P391 = self."!PREFIX__!subrule"("octint", "O") + $P392 = self."!PREFIX__!subrule"("octints", "o[") + $P393 = self."!PREFIX__!subrule"("octint", "o") + new $P394, "ResizablePMCArray" + push $P394, $P390 + push $P394, $P391 + push $P394, $P392 + push $P394, $P393 + .return ($P394) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("111_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("111_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx395_tgt - .local int rx395_pos - .local int rx395_off - .local int rx395_eos - .local int rx395_rep - .local pmc rx395_cur - (rx395_cur, rx395_pos, rx395_tgt) = self."!cursor_start"() - rx395_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx395_cur + .local string rx399_tgt + .local int rx399_pos + .local int rx399_off + .local int rx399_eos + .local int rx399_rep + .local pmc rx399_cur + (rx399_cur, rx399_pos, rx399_tgt) = self."!cursor_start"() + rx399_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx399_cur .local pmc match .lex "$/", match - length rx395_eos, rx395_tgt - gt rx395_pos, rx395_eos, rx395_done - set rx395_off, 0 - lt rx395_pos, 2, rx395_start - sub rx395_off, rx395_pos, 1 - substr rx395_tgt, rx395_tgt, rx395_off - rx395_start: + length rx399_eos, rx399_tgt + gt rx399_pos, rx399_eos, rx399_done + set rx399_off, 0 + lt rx399_pos, 2, rx399_start + sub rx399_off, rx399_pos, 1 + substr rx399_tgt, rx399_tgt, rx399_off + rx399_start: $I10 = self.'from'() - ne $I10, -1, rxscan402_done - goto rxscan402_scan - rxscan402_loop: - ($P10) = rx395_cur."from"() + ne $I10, -1, rxscan406_done + goto rxscan406_scan + rxscan406_loop: + ($P10) = rx399_cur."from"() inc $P10 - set rx395_pos, $P10 - ge rx395_pos, rx395_eos, rxscan402_done - rxscan402_scan: - set_addr $I10, rxscan402_loop - rx395_cur."!mark_push"(0, rx395_pos, $I10) - rxscan402_done: + set rx399_pos, $P10 + ge rx399_pos, rx399_eos, rxscan406_done + rxscan406_scan: + set_addr $I10, rxscan406_loop + rx399_cur."!mark_push"(0, rx399_pos, $I10) + rxscan406_done: .annotate 'line', 130 # rx subcapture "sym" - set_addr $I10, rxcap_403_fail - rx395_cur."!mark_push"(0, rx395_pos, $I10) + set_addr $I10, rxcap_407_fail + rx399_cur."!mark_push"(0, rx399_pos, $I10) # rx enumcharlist negate=0 - ge rx395_pos, rx395_eos, rx395_fail - sub $I10, rx395_pos, rx395_off - substr $S10, rx395_tgt, $I10, 1 + ge rx399_pos, rx399_eos, rx399_fail + sub $I10, rx399_pos, rx399_off + substr $S10, rx399_tgt, $I10, 1 index $I11, "xX", $S10 - lt $I11, 0, rx395_fail - inc rx395_pos - set_addr $I10, rxcap_403_fail - ($I12, $I11) = rx395_cur."!mark_peek"($I10) - rx395_cur."!cursor_pos"($I11) - ($P10) = rx395_cur."!cursor_start"() - $P10."!cursor_pass"(rx395_pos, "") - rx395_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, 0, rx399_fail + inc rx399_pos + set_addr $I10, rxcap_407_fail + ($I12, $I11) = rx399_cur."!mark_peek"($I10) + rx399_cur."!cursor_pos"($I11) + ($P10) = rx399_cur."!cursor_start"() + $P10."!cursor_pass"(rx399_pos, "") + rx399_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_403_done - rxcap_403_fail: - goto rx395_fail - rxcap_403_done: - alt404_0: - set_addr $I10, alt404_1 - rx395_cur."!mark_push"(0, rx395_pos, $I10) + goto rxcap_407_done + rxcap_407_fail: + goto rx399_fail + rxcap_407_done: + alt408_0: + set_addr $I10, alt408_1 + rx399_cur."!mark_push"(0, rx399_pos, $I10) # rx subrule "hexint" subtype=capture negate= - rx395_cur."!cursor_pos"(rx395_pos) - $P10 = rx395_cur."hexint"() - unless $P10, rx395_fail - rx395_cur."!mark_push"(0, -1, 0, $P10) + rx399_cur."!cursor_pos"(rx399_pos) + $P10 = rx399_cur."hexint"() + unless $P10, rx399_fail + rx399_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("hexint") - rx395_pos = $P10."pos"() - goto alt404_end - alt404_1: + rx399_pos = $P10."pos"() + goto alt408_end + alt408_1: # rx literal "[" - add $I11, rx395_pos, 1 - gt $I11, rx395_eos, rx395_fail - sub $I11, rx395_pos, rx395_off - substr $S10, rx395_tgt, $I11, 1 - ne $S10, "[", rx395_fail - add rx395_pos, 1 + add $I11, rx399_pos, 1 + gt $I11, rx399_eos, rx399_fail + sub $I11, rx399_pos, rx399_off + substr $S10, rx399_tgt, $I11, 1 + ne $S10, "[", rx399_fail + add rx399_pos, 1 # rx subrule "hexints" subtype=capture negate= - rx395_cur."!cursor_pos"(rx395_pos) - $P10 = rx395_cur."hexints"() - unless $P10, rx395_fail - rx395_cur."!mark_push"(0, -1, 0, $P10) + rx399_cur."!cursor_pos"(rx399_pos) + $P10 = rx399_cur."hexints"() + unless $P10, rx399_fail + rx399_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("hexints") - rx395_pos = $P10."pos"() + rx399_pos = $P10."pos"() # rx literal "]" - add $I11, rx395_pos, 1 - gt $I11, rx395_eos, rx395_fail - sub $I11, rx395_pos, rx395_off - substr $S10, rx395_tgt, $I11, 1 - ne $S10, "]", rx395_fail - add rx395_pos, 1 - alt404_end: + add $I11, rx399_pos, 1 + gt $I11, rx399_eos, rx399_fail + sub $I11, rx399_pos, rx399_off + substr $S10, rx399_tgt, $I11, 1 + ne $S10, "]", rx399_fail + add rx399_pos, 1 + alt408_end: # rx pass - rx395_cur."!cursor_pass"(rx395_pos, "backslash:sym") - rx395_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx395_pos) - .return (rx395_cur) - rx395_fail: -.annotate 'line', 3 - (rx395_rep, rx395_pos, $I10, $P10) = rx395_cur."!mark_fail"(0) - lt rx395_pos, -1, rx395_done - eq rx395_pos, -1, rx395_fail + rx399_cur."!cursor_pass"(rx399_pos, "backslash:sym") + rx399_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx399_pos) + .return (rx399_cur) + rx399_fail: +.annotate 'line', 3 + (rx399_rep, rx399_pos, $I10, $P10) = rx399_cur."!mark_fail"(0) + lt rx399_pos, -1, rx399_done + eq rx399_pos, -1, rx399_fail jump $I10 - rx395_done: - rx395_cur."!cursor_fail"() - rx395_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx395_cur) + rx399_done: + rx399_cur."!cursor_fail"() + rx399_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx399_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("112_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("112_1275599996.35368") :method .annotate 'line', 3 - $P397 = self."!PREFIX__!subrule"("hexints", "X[") - $P398 = self."!PREFIX__!subrule"("hexint", "X") - $P399 = self."!PREFIX__!subrule"("hexints", "x[") - $P400 = self."!PREFIX__!subrule"("hexint", "x") - new $P401, "ResizablePMCArray" - push $P401, $P397 - push $P401, $P398 - push $P401, $P399 - push $P401, $P400 - .return ($P401) + $P401 = self."!PREFIX__!subrule"("hexints", "X[") + $P402 = self."!PREFIX__!subrule"("hexint", "X") + $P403 = self."!PREFIX__!subrule"("hexints", "x[") + $P404 = self."!PREFIX__!subrule"("hexint", "x") + new $P405, "ResizablePMCArray" + push $P405, $P401 + push $P405, $P402 + push $P405, $P403 + push $P405, $P404 + .return ($P405) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("113_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("113_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx406_tgt - .local int rx406_pos - .local int rx406_off - .local int rx406_eos - .local int rx406_rep - .local pmc rx406_cur - (rx406_cur, rx406_pos, rx406_tgt) = self."!cursor_start"() - rx406_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx406_cur + .local string rx410_tgt + .local int rx410_pos + .local int rx410_off + .local int rx410_eos + .local int rx410_rep + .local pmc rx410_cur + (rx410_cur, rx410_pos, rx410_tgt) = self."!cursor_start"() + rx410_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx410_cur .local pmc match .lex "$/", match - length rx406_eos, rx406_tgt - gt rx406_pos, rx406_eos, rx406_done - set rx406_off, 0 - lt rx406_pos, 2, rx406_start - sub rx406_off, rx406_pos, 1 - substr rx406_tgt, rx406_tgt, rx406_off - rx406_start: + length rx410_eos, rx410_tgt + gt rx410_pos, rx410_eos, rx410_done + set rx410_off, 0 + lt rx410_pos, 2, rx410_start + sub rx410_off, rx410_pos, 1 + substr rx410_tgt, rx410_tgt, rx410_off + rx410_start: $I10 = self.'from'() - ne $I10, -1, rxscan411_done - goto rxscan411_scan - rxscan411_loop: - ($P10) = rx406_cur."from"() + ne $I10, -1, rxscan415_done + goto rxscan415_scan + rxscan415_loop: + ($P10) = rx410_cur."from"() inc $P10 - set rx406_pos, $P10 - ge rx406_pos, rx406_eos, rxscan411_done - rxscan411_scan: - set_addr $I10, rxscan411_loop - rx406_cur."!mark_push"(0, rx406_pos, $I10) - rxscan411_done: + set rx410_pos, $P10 + ge rx410_pos, rx410_eos, rxscan415_done + rxscan415_scan: + set_addr $I10, rxscan415_loop + rx410_cur."!mark_push"(0, rx410_pos, $I10) + rxscan415_done: .annotate 'line', 131 # rx subcapture "sym" - set_addr $I10, rxcap_412_fail - rx406_cur."!mark_push"(0, rx406_pos, $I10) + set_addr $I10, rxcap_416_fail + rx410_cur."!mark_push"(0, rx410_pos, $I10) # rx enumcharlist negate=0 - ge rx406_pos, rx406_eos, rx406_fail - sub $I10, rx406_pos, rx406_off - substr $S10, rx406_tgt, $I10, 1 + ge rx410_pos, rx410_eos, rx410_fail + sub $I10, rx410_pos, rx410_off + substr $S10, rx410_tgt, $I10, 1 index $I11, "cC", $S10 - lt $I11, 0, rx406_fail - inc rx406_pos - set_addr $I10, rxcap_412_fail - ($I12, $I11) = rx406_cur."!mark_peek"($I10) - rx406_cur."!cursor_pos"($I11) - ($P10) = rx406_cur."!cursor_start"() - $P10."!cursor_pass"(rx406_pos, "") - rx406_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, 0, rx410_fail + inc rx410_pos + set_addr $I10, rxcap_416_fail + ($I12, $I11) = rx410_cur."!mark_peek"($I10) + rx410_cur."!cursor_pos"($I11) + ($P10) = rx410_cur."!cursor_start"() + $P10."!cursor_pass"(rx410_pos, "") + rx410_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_412_done - rxcap_412_fail: - goto rx406_fail - rxcap_412_done: + goto rxcap_416_done + rxcap_416_fail: + goto rx410_fail + rxcap_416_done: # rx subrule "charspec" subtype=capture negate= - rx406_cur."!cursor_pos"(rx406_pos) - $P10 = rx406_cur."charspec"() - unless $P10, rx406_fail - rx406_cur."!mark_push"(0, -1, 0, $P10) + rx410_cur."!cursor_pos"(rx410_pos) + $P10 = rx410_cur."charspec"() + unless $P10, rx410_fail + rx410_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("charspec") - rx406_pos = $P10."pos"() + rx410_pos = $P10."pos"() # rx pass - rx406_cur."!cursor_pass"(rx406_pos, "backslash:sym") - rx406_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx406_pos) - .return (rx406_cur) - rx406_fail: -.annotate 'line', 3 - (rx406_rep, rx406_pos, $I10, $P10) = rx406_cur."!mark_fail"(0) - lt rx406_pos, -1, rx406_done - eq rx406_pos, -1, rx406_fail + rx410_cur."!cursor_pass"(rx410_pos, "backslash:sym") + rx410_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx410_pos) + .return (rx410_cur) + rx410_fail: +.annotate 'line', 3 + (rx410_rep, rx410_pos, $I10, $P10) = rx410_cur."!mark_fail"(0) + lt rx410_pos, -1, rx410_done + eq rx410_pos, -1, rx410_fail jump $I10 - rx406_done: - rx406_cur."!cursor_fail"() - rx406_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx406_cur) + rx410_done: + rx410_cur."!cursor_fail"() + rx410_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx410_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("114_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("114_1275599996.35368") :method .annotate 'line', 3 - $P408 = self."!PREFIX__!subrule"("charspec", "C") - $P409 = self."!PREFIX__!subrule"("charspec", "c") - new $P410, "ResizablePMCArray" - push $P410, $P408 - push $P410, $P409 - .return ($P410) + $P412 = self."!PREFIX__!subrule"("charspec", "C") + $P413 = self."!PREFIX__!subrule"("charspec", "c") + new $P414, "ResizablePMCArray" + push $P414, $P412 + push $P414, $P413 + .return ($P414) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("115_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("115_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx414_tgt - .local int rx414_pos - .local int rx414_off - .local int rx414_eos - .local int rx414_rep - .local pmc rx414_cur - (rx414_cur, rx414_pos, rx414_tgt) = self."!cursor_start"() - rx414_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx414_cur + .local string rx418_tgt + .local int rx418_pos + .local int rx418_off + .local int rx418_eos + .local int rx418_rep + .local pmc rx418_cur + (rx418_cur, rx418_pos, rx418_tgt) = self."!cursor_start"() + rx418_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx418_cur .local pmc match .lex "$/", match - length rx414_eos, rx414_tgt - gt rx414_pos, rx414_eos, rx414_done - set rx414_off, 0 - lt rx414_pos, 2, rx414_start - sub rx414_off, rx414_pos, 1 - substr rx414_tgt, rx414_tgt, rx414_off - rx414_start: + length rx418_eos, rx418_tgt + gt rx418_pos, rx418_eos, rx418_done + set rx418_off, 0 + lt rx418_pos, 2, rx418_start + sub rx418_off, rx418_pos, 1 + substr rx418_tgt, rx418_tgt, rx418_off + rx418_start: $I10 = self.'from'() - ne $I10, -1, rxscan418_done - goto rxscan418_scan - rxscan418_loop: - ($P10) = rx414_cur."from"() + ne $I10, -1, rxscan422_done + goto rxscan422_scan + rxscan422_loop: + ($P10) = rx418_cur."from"() inc $P10 - set rx414_pos, $P10 - ge rx414_pos, rx414_eos, rxscan418_done - rxscan418_scan: - set_addr $I10, rxscan418_loop - rx414_cur."!mark_push"(0, rx414_pos, $I10) - rxscan418_done: + set rx418_pos, $P10 + ge rx418_pos, rx418_eos, rxscan422_done + rxscan422_scan: + set_addr $I10, rxscan422_loop + rx418_cur."!mark_push"(0, rx418_pos, $I10) + rxscan422_done: .annotate 'line', 132 # rx literal "A" - add $I11, rx414_pos, 1 - gt $I11, rx414_eos, rx414_fail - sub $I11, rx414_pos, rx414_off - substr $S10, rx414_tgt, $I11, 1 - ne $S10, "A", rx414_fail - add rx414_pos, 1 + add $I11, rx418_pos, 1 + gt $I11, rx418_eos, rx418_fail + sub $I11, rx418_pos, rx418_off + substr $S10, rx418_tgt, $I11, 1 + ne $S10, "A", rx418_fail + add rx418_pos, 1 # rx subrule "obs" subtype=method negate= - rx414_cur."!cursor_pos"(rx414_pos) - $P10 = rx414_cur."obs"("\\A as beginning-of-string matcher", "^") - unless $P10, rx414_fail - rx414_pos = $P10."pos"() + rx418_cur."!cursor_pos"(rx418_pos) + $P10 = rx418_cur."obs"("\\A as beginning-of-string matcher", "^") + unless $P10, rx418_fail + rx418_pos = $P10."pos"() # rx pass - rx414_cur."!cursor_pass"(rx414_pos, "backslash:sym") - rx414_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx414_pos) - .return (rx414_cur) - rx414_fail: -.annotate 'line', 3 - (rx414_rep, rx414_pos, $I10, $P10) = rx414_cur."!mark_fail"(0) - lt rx414_pos, -1, rx414_done - eq rx414_pos, -1, rx414_fail + rx418_cur."!cursor_pass"(rx418_pos, "backslash:sym") + rx418_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx418_pos) + .return (rx418_cur) + rx418_fail: +.annotate 'line', 3 + (rx418_rep, rx418_pos, $I10, $P10) = rx418_cur."!mark_fail"(0) + lt rx418_pos, -1, rx418_done + eq rx418_pos, -1, rx418_fail jump $I10 - rx414_done: - rx414_cur."!cursor_fail"() - rx414_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx414_cur) + rx418_done: + rx418_cur."!cursor_fail"() + rx418_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx418_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("116_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("116_1275599996.35368") :method .annotate 'line', 3 - $P416 = self."!PREFIX__!subrule"("", "A") - new $P417, "ResizablePMCArray" - push $P417, $P416 - .return ($P417) + $P420 = self."!PREFIX__!subrule"("", "A") + new $P421, "ResizablePMCArray" + push $P421, $P420 + .return ($P421) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("117_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("117_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx420_tgt - .local int rx420_pos - .local int rx420_off - .local int rx420_eos - .local int rx420_rep - .local pmc rx420_cur - (rx420_cur, rx420_pos, rx420_tgt) = self."!cursor_start"() - rx420_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx420_cur + .local string rx424_tgt + .local int rx424_pos + .local int rx424_off + .local int rx424_eos + .local int rx424_rep + .local pmc rx424_cur + (rx424_cur, rx424_pos, rx424_tgt) = self."!cursor_start"() + rx424_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx424_cur .local pmc match .lex "$/", match - length rx420_eos, rx420_tgt - gt rx420_pos, rx420_eos, rx420_done - set rx420_off, 0 - lt rx420_pos, 2, rx420_start - sub rx420_off, rx420_pos, 1 - substr rx420_tgt, rx420_tgt, rx420_off - rx420_start: + length rx424_eos, rx424_tgt + gt rx424_pos, rx424_eos, rx424_done + set rx424_off, 0 + lt rx424_pos, 2, rx424_start + sub rx424_off, rx424_pos, 1 + substr rx424_tgt, rx424_tgt, rx424_off + rx424_start: $I10 = self.'from'() - ne $I10, -1, rxscan424_done - goto rxscan424_scan - rxscan424_loop: - ($P10) = rx420_cur."from"() + ne $I10, -1, rxscan428_done + goto rxscan428_scan + rxscan428_loop: + ($P10) = rx424_cur."from"() inc $P10 - set rx420_pos, $P10 - ge rx420_pos, rx420_eos, rxscan424_done - rxscan424_scan: - set_addr $I10, rxscan424_loop - rx420_cur."!mark_push"(0, rx420_pos, $I10) - rxscan424_done: + set rx424_pos, $P10 + ge rx424_pos, rx424_eos, rxscan428_done + rxscan428_scan: + set_addr $I10, rxscan428_loop + rx424_cur."!mark_push"(0, rx424_pos, $I10) + rxscan428_done: .annotate 'line', 133 # rx literal "z" - add $I11, rx420_pos, 1 - gt $I11, rx420_eos, rx420_fail - sub $I11, rx420_pos, rx420_off - substr $S10, rx420_tgt, $I11, 1 - ne $S10, "z", rx420_fail - add rx420_pos, 1 + add $I11, rx424_pos, 1 + gt $I11, rx424_eos, rx424_fail + sub $I11, rx424_pos, rx424_off + substr $S10, rx424_tgt, $I11, 1 + ne $S10, "z", rx424_fail + add rx424_pos, 1 # rx subrule "obs" subtype=method negate= - rx420_cur."!cursor_pos"(rx420_pos) - $P10 = rx420_cur."obs"("\\z as end-of-string matcher", "$") - unless $P10, rx420_fail - rx420_pos = $P10."pos"() + rx424_cur."!cursor_pos"(rx424_pos) + $P10 = rx424_cur."obs"("\\z as end-of-string matcher", "$") + unless $P10, rx424_fail + rx424_pos = $P10."pos"() # rx pass - rx420_cur."!cursor_pass"(rx420_pos, "backslash:sym") - rx420_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx420_pos) - .return (rx420_cur) - rx420_fail: -.annotate 'line', 3 - (rx420_rep, rx420_pos, $I10, $P10) = rx420_cur."!mark_fail"(0) - lt rx420_pos, -1, rx420_done - eq rx420_pos, -1, rx420_fail + rx424_cur."!cursor_pass"(rx424_pos, "backslash:sym") + rx424_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx424_pos) + .return (rx424_cur) + rx424_fail: +.annotate 'line', 3 + (rx424_rep, rx424_pos, $I10, $P10) = rx424_cur."!mark_fail"(0) + lt rx424_pos, -1, rx424_done + eq rx424_pos, -1, rx424_fail jump $I10 - rx420_done: - rx420_cur."!cursor_fail"() - rx420_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx420_cur) + rx424_done: + rx424_cur."!cursor_fail"() + rx424_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx424_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("118_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("118_1275599996.35368") :method .annotate 'line', 3 - $P422 = self."!PREFIX__!subrule"("", "z") - new $P423, "ResizablePMCArray" - push $P423, $P422 - .return ($P423) + $P426 = self."!PREFIX__!subrule"("", "z") + new $P427, "ResizablePMCArray" + push $P427, $P426 + .return ($P427) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("119_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("119_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx426_tgt - .local int rx426_pos - .local int rx426_off - .local int rx426_eos - .local int rx426_rep - .local pmc rx426_cur - (rx426_cur, rx426_pos, rx426_tgt) = self."!cursor_start"() - rx426_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx426_cur + .local string rx430_tgt + .local int rx430_pos + .local int rx430_off + .local int rx430_eos + .local int rx430_rep + .local pmc rx430_cur + (rx430_cur, rx430_pos, rx430_tgt) = self."!cursor_start"() + rx430_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx430_cur .local pmc match .lex "$/", match - length rx426_eos, rx426_tgt - gt rx426_pos, rx426_eos, rx426_done - set rx426_off, 0 - lt rx426_pos, 2, rx426_start - sub rx426_off, rx426_pos, 1 - substr rx426_tgt, rx426_tgt, rx426_off - rx426_start: + length rx430_eos, rx430_tgt + gt rx430_pos, rx430_eos, rx430_done + set rx430_off, 0 + lt rx430_pos, 2, rx430_start + sub rx430_off, rx430_pos, 1 + substr rx430_tgt, rx430_tgt, rx430_off + rx430_start: $I10 = self.'from'() - ne $I10, -1, rxscan430_done - goto rxscan430_scan - rxscan430_loop: - ($P10) = rx426_cur."from"() + ne $I10, -1, rxscan434_done + goto rxscan434_scan + rxscan434_loop: + ($P10) = rx430_cur."from"() inc $P10 - set rx426_pos, $P10 - ge rx426_pos, rx426_eos, rxscan430_done - rxscan430_scan: - set_addr $I10, rxscan430_loop - rx426_cur."!mark_push"(0, rx426_pos, $I10) - rxscan430_done: + set rx430_pos, $P10 + ge rx430_pos, rx430_eos, rxscan434_done + rxscan434_scan: + set_addr $I10, rxscan434_loop + rx430_cur."!mark_push"(0, rx430_pos, $I10) + rxscan434_done: .annotate 'line', 134 # rx literal "Z" - add $I11, rx426_pos, 1 - gt $I11, rx426_eos, rx426_fail - sub $I11, rx426_pos, rx426_off - substr $S10, rx426_tgt, $I11, 1 - ne $S10, "Z", rx426_fail - add rx426_pos, 1 + add $I11, rx430_pos, 1 + gt $I11, rx430_eos, rx430_fail + sub $I11, rx430_pos, rx430_off + substr $S10, rx430_tgt, $I11, 1 + ne $S10, "Z", rx430_fail + add rx430_pos, 1 # rx subrule "obs" subtype=method negate= - rx426_cur."!cursor_pos"(rx426_pos) - $P10 = rx426_cur."obs"("\\Z as end-of-string matcher", "\\n?$") - unless $P10, rx426_fail - rx426_pos = $P10."pos"() + rx430_cur."!cursor_pos"(rx430_pos) + $P10 = rx430_cur."obs"("\\Z as end-of-string matcher", "\\n?$") + unless $P10, rx430_fail + rx430_pos = $P10."pos"() # rx pass - rx426_cur."!cursor_pass"(rx426_pos, "backslash:sym") - rx426_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx426_pos) - .return (rx426_cur) - rx426_fail: -.annotate 'line', 3 - (rx426_rep, rx426_pos, $I10, $P10) = rx426_cur."!mark_fail"(0) - lt rx426_pos, -1, rx426_done - eq rx426_pos, -1, rx426_fail + rx430_cur."!cursor_pass"(rx430_pos, "backslash:sym") + rx430_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx430_pos) + .return (rx430_cur) + rx430_fail: +.annotate 'line', 3 + (rx430_rep, rx430_pos, $I10, $P10) = rx430_cur."!mark_fail"(0) + lt rx430_pos, -1, rx430_done + eq rx430_pos, -1, rx430_fail jump $I10 - rx426_done: - rx426_cur."!cursor_fail"() - rx426_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx426_cur) + rx430_done: + rx430_cur."!cursor_fail"() + rx430_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx430_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("120_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("120_1275599996.35368") :method .annotate 'line', 3 - $P428 = self."!PREFIX__!subrule"("", "Z") - new $P429, "ResizablePMCArray" - push $P429, $P428 - .return ($P429) + $P432 = self."!PREFIX__!subrule"("", "Z") + new $P433, "ResizablePMCArray" + push $P433, $P432 + .return ($P433) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("121_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("121_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx432_tgt - .local int rx432_pos - .local int rx432_off - .local int rx432_eos - .local int rx432_rep - .local pmc rx432_cur - (rx432_cur, rx432_pos, rx432_tgt) = self."!cursor_start"() - rx432_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx432_cur + .local string rx436_tgt + .local int rx436_pos + .local int rx436_off + .local int rx436_eos + .local int rx436_rep + .local pmc rx436_cur + (rx436_cur, rx436_pos, rx436_tgt) = self."!cursor_start"() + rx436_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx436_cur .local pmc match .lex "$/", match - length rx432_eos, rx432_tgt - gt rx432_pos, rx432_eos, rx432_done - set rx432_off, 0 - lt rx432_pos, 2, rx432_start - sub rx432_off, rx432_pos, 1 - substr rx432_tgt, rx432_tgt, rx432_off - rx432_start: + length rx436_eos, rx436_tgt + gt rx436_pos, rx436_eos, rx436_done + set rx436_off, 0 + lt rx436_pos, 2, rx436_start + sub rx436_off, rx436_pos, 1 + substr rx436_tgt, rx436_tgt, rx436_off + rx436_start: $I10 = self.'from'() - ne $I10, -1, rxscan436_done - goto rxscan436_scan - rxscan436_loop: - ($P10) = rx432_cur."from"() + ne $I10, -1, rxscan440_done + goto rxscan440_scan + rxscan440_loop: + ($P10) = rx436_cur."from"() inc $P10 - set rx432_pos, $P10 - ge rx432_pos, rx432_eos, rxscan436_done - rxscan436_scan: - set_addr $I10, rxscan436_loop - rx432_cur."!mark_push"(0, rx432_pos, $I10) - rxscan436_done: + set rx436_pos, $P10 + ge rx436_pos, rx436_eos, rxscan440_done + rxscan440_scan: + set_addr $I10, rxscan440_loop + rx436_cur."!mark_push"(0, rx436_pos, $I10) + rxscan440_done: .annotate 'line', 135 # rx literal "Q" - add $I11, rx432_pos, 1 - gt $I11, rx432_eos, rx432_fail - sub $I11, rx432_pos, rx432_off - substr $S10, rx432_tgt, $I11, 1 - ne $S10, "Q", rx432_fail - add rx432_pos, 1 + add $I11, rx436_pos, 1 + gt $I11, rx436_eos, rx436_fail + sub $I11, rx436_pos, rx436_off + substr $S10, rx436_tgt, $I11, 1 + ne $S10, "Q", rx436_fail + add rx436_pos, 1 # rx subrule "obs" subtype=method negate= - rx432_cur."!cursor_pos"(rx432_pos) - $P10 = rx432_cur."obs"("\\Q as quotemeta", "quotes or literal variable match") - unless $P10, rx432_fail - rx432_pos = $P10."pos"() + rx436_cur."!cursor_pos"(rx436_pos) + $P10 = rx436_cur."obs"("\\Q as quotemeta", "quotes or literal variable match") + unless $P10, rx436_fail + rx436_pos = $P10."pos"() # rx pass - rx432_cur."!cursor_pass"(rx432_pos, "backslash:sym") - rx432_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx432_pos) - .return (rx432_cur) - rx432_fail: -.annotate 'line', 3 - (rx432_rep, rx432_pos, $I10, $P10) = rx432_cur."!mark_fail"(0) - lt rx432_pos, -1, rx432_done - eq rx432_pos, -1, rx432_fail + rx436_cur."!cursor_pass"(rx436_pos, "backslash:sym") + rx436_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx436_pos) + .return (rx436_cur) + rx436_fail: +.annotate 'line', 3 + (rx436_rep, rx436_pos, $I10, $P10) = rx436_cur."!mark_fail"(0) + lt rx436_pos, -1, rx436_done + eq rx436_pos, -1, rx436_fail jump $I10 - rx432_done: - rx432_cur."!cursor_fail"() - rx432_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx432_cur) + rx436_done: + rx436_cur."!cursor_fail"() + rx436_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx436_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("122_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("122_1275599996.35368") :method .annotate 'line', 3 - $P434 = self."!PREFIX__!subrule"("", "Q") - new $P435, "ResizablePMCArray" - push $P435, $P434 - .return ($P435) + $P438 = self."!PREFIX__!subrule"("", "Q") + new $P439, "ResizablePMCArray" + push $P439, $P438 + .return ($P439) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "backslash:sym" :subid("123_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "backslash:sym" :subid("123_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx438_tgt - .local int rx438_pos - .local int rx438_off - .local int rx438_eos - .local int rx438_rep - .local pmc rx438_cur - (rx438_cur, rx438_pos, rx438_tgt) = self."!cursor_start"() - rx438_cur."!cursor_debug"("START ", "backslash:sym") - .lex unicode:"$\x{a2}", rx438_cur + .local string rx442_tgt + .local int rx442_pos + .local int rx442_off + .local int rx442_eos + .local int rx442_rep + .local pmc rx442_cur + (rx442_cur, rx442_pos, rx442_tgt) = self."!cursor_start"() + rx442_cur."!cursor_debug"("START ", "backslash:sym") + .lex unicode:"$\x{a2}", rx442_cur .local pmc match .lex "$/", match - length rx438_eos, rx438_tgt - gt rx438_pos, rx438_eos, rx438_done - set rx438_off, 0 - lt rx438_pos, 2, rx438_start - sub rx438_off, rx438_pos, 1 - substr rx438_tgt, rx438_tgt, rx438_off - rx438_start: + length rx442_eos, rx442_tgt + gt rx442_pos, rx442_eos, rx442_done + set rx442_off, 0 + lt rx442_pos, 2, rx442_start + sub rx442_off, rx442_pos, 1 + substr rx442_tgt, rx442_tgt, rx442_off + rx442_start: $I10 = self.'from'() - ne $I10, -1, rxscan441_done - goto rxscan441_scan - rxscan441_loop: - ($P10) = rx438_cur."from"() + ne $I10, -1, rxscan445_done + goto rxscan445_scan + rxscan445_loop: + ($P10) = rx442_cur."from"() inc $P10 - set rx438_pos, $P10 - ge rx438_pos, rx438_eos, rxscan441_done - rxscan441_scan: - set_addr $I10, rxscan441_loop - rx438_cur."!mark_push"(0, rx438_pos, $I10) - rxscan441_done: + set rx442_pos, $P10 + ge rx442_pos, rx442_eos, rxscan445_done + rxscan445_scan: + set_addr $I10, rxscan445_loop + rx442_cur."!mark_push"(0, rx442_pos, $I10) + rxscan445_done: .annotate 'line', 136 # rx charclass W - ge rx438_pos, rx438_eos, rx438_fail - sub $I10, rx438_pos, rx438_off - is_cclass $I11, 8192, rx438_tgt, $I10 - if $I11, rx438_fail - inc rx438_pos + ge rx442_pos, rx442_eos, rx442_fail + sub $I10, rx442_pos, rx442_off + is_cclass $I11, 8192, rx442_tgt, $I10 + if $I11, rx442_fail + inc rx442_pos # rx pass - rx438_cur."!cursor_pass"(rx438_pos, "backslash:sym") - rx438_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx438_pos) - .return (rx438_cur) - rx438_fail: -.annotate 'line', 3 - (rx438_rep, rx438_pos, $I10, $P10) = rx438_cur."!mark_fail"(0) - lt rx438_pos, -1, rx438_done - eq rx438_pos, -1, rx438_fail + rx442_cur."!cursor_pass"(rx442_pos, "backslash:sym") + rx442_cur."!cursor_debug"("PASS ", "backslash:sym", " at pos=", rx442_pos) + .return (rx442_cur) + rx442_fail: +.annotate 'line', 3 + (rx442_rep, rx442_pos, $I10, $P10) = rx442_cur."!mark_fail"(0) + lt rx442_pos, -1, rx442_done + eq rx442_pos, -1, rx442_fail jump $I10 - rx438_done: - rx438_cur."!cursor_fail"() - rx438_cur."!cursor_debug"("FAIL ", "backslash:sym") - .return (rx438_cur) + rx442_done: + rx442_cur."!cursor_fail"() + rx442_cur."!cursor_debug"("FAIL ", "backslash:sym") + .return (rx442_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__backslash:sym" :subid("124_1275511689.56967") :method +.sub "!PREFIX__backslash:sym" :subid("124_1275599996.35368") :method .annotate 'line', 3 - new $P440, "ResizablePMCArray" - push $P440, "" - .return ($P440) + new $P444, "ResizablePMCArray" + push $P444, "" + .return ($P444) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "assertion" :subid("125_1275511689.56967") :method +.sub "assertion" :subid("125_1275599996.35368") :method .annotate 'line', 138 - $P443 = self."!protoregex"("assertion") - .return ($P443) + $P447 = self."!protoregex"("assertion") + .return ($P447) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__assertion" :subid("126_1275511689.56967") :method +.sub "!PREFIX__assertion" :subid("126_1275599996.35368") :method .annotate 'line', 138 - $P445 = self."!PREFIX__!protoregex"("assertion") - .return ($P445) + $P449 = self."!PREFIX__!protoregex"("assertion") + .return ($P449) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "assertion:sym" :subid("127_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "assertion:sym" :subid("127_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .const 'Sub' $P454 = "129_1275511689.56967" - capture_lex $P454 - .local string rx447_tgt - .local int rx447_pos - .local int rx447_off - .local int rx447_eos - .local int rx447_rep - .local pmc rx447_cur - (rx447_cur, rx447_pos, rx447_tgt) = self."!cursor_start"() - rx447_cur."!cursor_debug"("START ", "assertion:sym") - .lex unicode:"$\x{a2}", rx447_cur + .const 'Sub' $P458 = "129_1275599996.35368" + capture_lex $P458 + .local string rx451_tgt + .local int rx451_pos + .local int rx451_off + .local int rx451_eos + .local int rx451_rep + .local pmc rx451_cur + (rx451_cur, rx451_pos, rx451_tgt) = self."!cursor_start"() + rx451_cur."!cursor_debug"("START ", "assertion:sym") + .lex unicode:"$\x{a2}", rx451_cur .local pmc match .lex "$/", match - length rx447_eos, rx447_tgt - gt rx447_pos, rx447_eos, rx447_done - set rx447_off, 0 - lt rx447_pos, 2, rx447_start - sub rx447_off, rx447_pos, 1 - substr rx447_tgt, rx447_tgt, rx447_off - rx447_start: + length rx451_eos, rx451_tgt + gt rx451_pos, rx451_eos, rx451_done + set rx451_off, 0 + lt rx451_pos, 2, rx451_start + sub rx451_off, rx451_pos, 1 + substr rx451_tgt, rx451_tgt, rx451_off + rx451_start: $I10 = self.'from'() - ne $I10, -1, rxscan451_done - goto rxscan451_scan - rxscan451_loop: - ($P10) = rx447_cur."from"() + ne $I10, -1, rxscan455_done + goto rxscan455_scan + rxscan455_loop: + ($P10) = rx451_cur."from"() inc $P10 - set rx447_pos, $P10 - ge rx447_pos, rx447_eos, rxscan451_done - rxscan451_scan: - set_addr $I10, rxscan451_loop - rx447_cur."!mark_push"(0, rx447_pos, $I10) - rxscan451_done: + set rx451_pos, $P10 + ge rx451_pos, rx451_eos, rxscan455_done + rxscan455_scan: + set_addr $I10, rxscan455_loop + rx451_cur."!mark_push"(0, rx451_pos, $I10) + rxscan455_done: .annotate 'line', 140 # rx literal "?" - add $I11, rx447_pos, 1 - gt $I11, rx447_eos, rx447_fail - sub $I11, rx447_pos, rx447_off - substr $S10, rx447_tgt, $I11, 1 - ne $S10, "?", rx447_fail - add rx447_pos, 1 - alt452_0: - set_addr $I10, alt452_1 - rx447_cur."!mark_push"(0, rx447_pos, $I10) + add $I11, rx451_pos, 1 + gt $I11, rx451_eos, rx451_fail + sub $I11, rx451_pos, rx451_off + substr $S10, rx451_tgt, $I11, 1 + ne $S10, "?", rx451_fail + add rx451_pos, 1 + alt456_0: + set_addr $I10, alt456_1 + rx451_cur."!mark_push"(0, rx451_pos, $I10) # rx subrule "before" subtype=zerowidth negate= - rx447_cur."!cursor_pos"(rx447_pos) - .const 'Sub' $P454 = "129_1275511689.56967" - capture_lex $P454 - $P10 = rx447_cur."before"($P454) - unless $P10, rx447_fail - goto alt452_end - alt452_1: + rx451_cur."!cursor_pos"(rx451_pos) + .const 'Sub' $P458 = "129_1275599996.35368" + capture_lex $P458 + $P10 = rx451_cur."before"($P458) + unless $P10, rx451_fail + goto alt456_end + alt456_1: # rx subrule "assertion" subtype=capture negate= - rx447_cur."!cursor_pos"(rx447_pos) - $P10 = rx447_cur."assertion"() - unless $P10, rx447_fail - rx447_cur."!mark_push"(0, -1, 0, $P10) + rx451_cur."!cursor_pos"(rx451_pos) + $P10 = rx451_cur."assertion"() + unless $P10, rx451_fail + rx451_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("assertion") - rx447_pos = $P10."pos"() - alt452_end: + rx451_pos = $P10."pos"() + alt456_end: # rx pass - rx447_cur."!cursor_pass"(rx447_pos, "assertion:sym") - rx447_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx447_pos) - .return (rx447_cur) - rx447_fail: -.annotate 'line', 3 - (rx447_rep, rx447_pos, $I10, $P10) = rx447_cur."!mark_fail"(0) - lt rx447_pos, -1, rx447_done - eq rx447_pos, -1, rx447_fail + rx451_cur."!cursor_pass"(rx451_pos, "assertion:sym") + rx451_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx451_pos) + .return (rx451_cur) + rx451_fail: +.annotate 'line', 3 + (rx451_rep, rx451_pos, $I10, $P10) = rx451_cur."!mark_fail"(0) + lt rx451_pos, -1, rx451_done + eq rx451_pos, -1, rx451_fail jump $I10 - rx447_done: - rx447_cur."!cursor_fail"() - rx447_cur."!cursor_debug"("FAIL ", "assertion:sym") - .return (rx447_cur) + rx451_done: + rx451_cur."!cursor_fail"() + rx451_cur."!cursor_debug"("FAIL ", "assertion:sym") + .return (rx451_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__assertion:sym" :subid("128_1275511689.56967") :method +.sub "!PREFIX__assertion:sym" :subid("128_1275599996.35368") :method .annotate 'line', 3 - $P449 = self."!PREFIX__!subrule"("assertion", "?") - new $P450, "ResizablePMCArray" - push $P450, $P449 - push $P450, "?" - .return ($P450) + $P453 = self."!PREFIX__!subrule"("assertion", "?") + new $P454, "ResizablePMCArray" + push $P454, $P453 + push $P454, "?" + .return ($P454) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block453" :anon :subid("129_1275511689.56967") :method :outer("127_1275511689.56967") +.sub "_block457" :anon :subid("129_1275599996.35368") :method :outer("127_1275599996.35368") .annotate 'line', 140 - .local string rx455_tgt - .local int rx455_pos - .local int rx455_off - .local int rx455_eos - .local int rx455_rep - .local pmc rx455_cur - (rx455_cur, rx455_pos, rx455_tgt) = self."!cursor_start"() - rx455_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx455_cur + .local string rx459_tgt + .local int rx459_pos + .local int rx459_off + .local int rx459_eos + .local int rx459_rep + .local pmc rx459_cur + (rx459_cur, rx459_pos, rx459_tgt) = self."!cursor_start"() + rx459_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx459_cur .local pmc match .lex "$/", match - length rx455_eos, rx455_tgt - gt rx455_pos, rx455_eos, rx455_done - set rx455_off, 0 - lt rx455_pos, 2, rx455_start - sub rx455_off, rx455_pos, 1 - substr rx455_tgt, rx455_tgt, rx455_off - rx455_start: + length rx459_eos, rx459_tgt + gt rx459_pos, rx459_eos, rx459_done + set rx459_off, 0 + lt rx459_pos, 2, rx459_start + sub rx459_off, rx459_pos, 1 + substr rx459_tgt, rx459_tgt, rx459_off + rx459_start: $I10 = self.'from'() - ne $I10, -1, rxscan456_done - goto rxscan456_scan - rxscan456_loop: - ($P10) = rx455_cur."from"() + ne $I10, -1, rxscan460_done + goto rxscan460_scan + rxscan460_loop: + ($P10) = rx459_cur."from"() inc $P10 - set rx455_pos, $P10 - ge rx455_pos, rx455_eos, rxscan456_done - rxscan456_scan: - set_addr $I10, rxscan456_loop - rx455_cur."!mark_push"(0, rx455_pos, $I10) - rxscan456_done: + set rx459_pos, $P10 + ge rx459_pos, rx459_eos, rxscan460_done + rxscan460_scan: + set_addr $I10, rxscan460_loop + rx459_cur."!mark_push"(0, rx459_pos, $I10) + rxscan460_done: # rx literal ">" - add $I11, rx455_pos, 1 - gt $I11, rx455_eos, rx455_fail - sub $I11, rx455_pos, rx455_off - substr $S10, rx455_tgt, $I11, 1 - ne $S10, ">", rx455_fail - add rx455_pos, 1 + add $I11, rx459_pos, 1 + gt $I11, rx459_eos, rx459_fail + sub $I11, rx459_pos, rx459_off + substr $S10, rx459_tgt, $I11, 1 + ne $S10, ">", rx459_fail + add rx459_pos, 1 # rx pass - rx455_cur."!cursor_pass"(rx455_pos, "") - rx455_cur."!cursor_debug"("PASS ", "", " at pos=", rx455_pos) - .return (rx455_cur) - rx455_fail: - (rx455_rep, rx455_pos, $I10, $P10) = rx455_cur."!mark_fail"(0) - lt rx455_pos, -1, rx455_done - eq rx455_pos, -1, rx455_fail + rx459_cur."!cursor_pass"(rx459_pos, "") + rx459_cur."!cursor_debug"("PASS ", "", " at pos=", rx459_pos) + .return (rx459_cur) + rx459_fail: + (rx459_rep, rx459_pos, $I10, $P10) = rx459_cur."!mark_fail"(0) + lt rx459_pos, -1, rx459_done + eq rx459_pos, -1, rx459_fail jump $I10 - rx455_done: - rx455_cur."!cursor_fail"() - rx455_cur."!cursor_debug"("FAIL ", "") - .return (rx455_cur) + rx459_done: + rx459_cur."!cursor_fail"() + rx459_cur."!cursor_debug"("FAIL ", "") + .return (rx459_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "assertion:sym" :subid("130_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "assertion:sym" :subid("130_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .const 'Sub' $P465 = "132_1275511689.56967" - capture_lex $P465 - .local string rx458_tgt - .local int rx458_pos - .local int rx458_off - .local int rx458_eos - .local int rx458_rep - .local pmc rx458_cur - (rx458_cur, rx458_pos, rx458_tgt) = self."!cursor_start"() - rx458_cur."!cursor_debug"("START ", "assertion:sym") - .lex unicode:"$\x{a2}", rx458_cur + .const 'Sub' $P469 = "132_1275599996.35368" + capture_lex $P469 + .local string rx462_tgt + .local int rx462_pos + .local int rx462_off + .local int rx462_eos + .local int rx462_rep + .local pmc rx462_cur + (rx462_cur, rx462_pos, rx462_tgt) = self."!cursor_start"() + rx462_cur."!cursor_debug"("START ", "assertion:sym") + .lex unicode:"$\x{a2}", rx462_cur .local pmc match .lex "$/", match - length rx458_eos, rx458_tgt - gt rx458_pos, rx458_eos, rx458_done - set rx458_off, 0 - lt rx458_pos, 2, rx458_start - sub rx458_off, rx458_pos, 1 - substr rx458_tgt, rx458_tgt, rx458_off - rx458_start: + length rx462_eos, rx462_tgt + gt rx462_pos, rx462_eos, rx462_done + set rx462_off, 0 + lt rx462_pos, 2, rx462_start + sub rx462_off, rx462_pos, 1 + substr rx462_tgt, rx462_tgt, rx462_off + rx462_start: $I10 = self.'from'() - ne $I10, -1, rxscan462_done - goto rxscan462_scan - rxscan462_loop: - ($P10) = rx458_cur."from"() + ne $I10, -1, rxscan466_done + goto rxscan466_scan + rxscan466_loop: + ($P10) = rx462_cur."from"() inc $P10 - set rx458_pos, $P10 - ge rx458_pos, rx458_eos, rxscan462_done - rxscan462_scan: - set_addr $I10, rxscan462_loop - rx458_cur."!mark_push"(0, rx458_pos, $I10) - rxscan462_done: + set rx462_pos, $P10 + ge rx462_pos, rx462_eos, rxscan466_done + rxscan466_scan: + set_addr $I10, rxscan466_loop + rx462_cur."!mark_push"(0, rx462_pos, $I10) + rxscan466_done: .annotate 'line', 141 # rx literal "!" - add $I11, rx458_pos, 1 - gt $I11, rx458_eos, rx458_fail - sub $I11, rx458_pos, rx458_off - substr $S10, rx458_tgt, $I11, 1 - ne $S10, "!", rx458_fail - add rx458_pos, 1 - alt463_0: - set_addr $I10, alt463_1 - rx458_cur."!mark_push"(0, rx458_pos, $I10) + add $I11, rx462_pos, 1 + gt $I11, rx462_eos, rx462_fail + sub $I11, rx462_pos, rx462_off + substr $S10, rx462_tgt, $I11, 1 + ne $S10, "!", rx462_fail + add rx462_pos, 1 + alt467_0: + set_addr $I10, alt467_1 + rx462_cur."!mark_push"(0, rx462_pos, $I10) # rx subrule "before" subtype=zerowidth negate= - rx458_cur."!cursor_pos"(rx458_pos) - .const 'Sub' $P465 = "132_1275511689.56967" - capture_lex $P465 - $P10 = rx458_cur."before"($P465) - unless $P10, rx458_fail - goto alt463_end - alt463_1: + rx462_cur."!cursor_pos"(rx462_pos) + .const 'Sub' $P469 = "132_1275599996.35368" + capture_lex $P469 + $P10 = rx462_cur."before"($P469) + unless $P10, rx462_fail + goto alt467_end + alt467_1: # rx subrule "assertion" subtype=capture negate= - rx458_cur."!cursor_pos"(rx458_pos) - $P10 = rx458_cur."assertion"() - unless $P10, rx458_fail - rx458_cur."!mark_push"(0, -1, 0, $P10) + rx462_cur."!cursor_pos"(rx462_pos) + $P10 = rx462_cur."assertion"() + unless $P10, rx462_fail + rx462_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("assertion") - rx458_pos = $P10."pos"() - alt463_end: + rx462_pos = $P10."pos"() + alt467_end: # rx pass - rx458_cur."!cursor_pass"(rx458_pos, "assertion:sym") - rx458_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx458_pos) - .return (rx458_cur) - rx458_fail: -.annotate 'line', 3 - (rx458_rep, rx458_pos, $I10, $P10) = rx458_cur."!mark_fail"(0) - lt rx458_pos, -1, rx458_done - eq rx458_pos, -1, rx458_fail + rx462_cur."!cursor_pass"(rx462_pos, "assertion:sym") + rx462_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx462_pos) + .return (rx462_cur) + rx462_fail: +.annotate 'line', 3 + (rx462_rep, rx462_pos, $I10, $P10) = rx462_cur."!mark_fail"(0) + lt rx462_pos, -1, rx462_done + eq rx462_pos, -1, rx462_fail jump $I10 - rx458_done: - rx458_cur."!cursor_fail"() - rx458_cur."!cursor_debug"("FAIL ", "assertion:sym") - .return (rx458_cur) + rx462_done: + rx462_cur."!cursor_fail"() + rx462_cur."!cursor_debug"("FAIL ", "assertion:sym") + .return (rx462_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__assertion:sym" :subid("131_1275511689.56967") :method +.sub "!PREFIX__assertion:sym" :subid("131_1275599996.35368") :method .annotate 'line', 3 - $P460 = self."!PREFIX__!subrule"("assertion", "!") - new $P461, "ResizablePMCArray" - push $P461, $P460 - push $P461, "!" - .return ($P461) + $P464 = self."!PREFIX__!subrule"("assertion", "!") + new $P465, "ResizablePMCArray" + push $P465, $P464 + push $P465, "!" + .return ($P465) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block464" :anon :subid("132_1275511689.56967") :method :outer("130_1275511689.56967") +.sub "_block468" :anon :subid("132_1275599996.35368") :method :outer("130_1275599996.35368") .annotate 'line', 141 - .local string rx466_tgt - .local int rx466_pos - .local int rx466_off - .local int rx466_eos - .local int rx466_rep - .local pmc rx466_cur - (rx466_cur, rx466_pos, rx466_tgt) = self."!cursor_start"() - rx466_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx466_cur + .local string rx470_tgt + .local int rx470_pos + .local int rx470_off + .local int rx470_eos + .local int rx470_rep + .local pmc rx470_cur + (rx470_cur, rx470_pos, rx470_tgt) = self."!cursor_start"() + rx470_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx470_cur .local pmc match .lex "$/", match - length rx466_eos, rx466_tgt - gt rx466_pos, rx466_eos, rx466_done - set rx466_off, 0 - lt rx466_pos, 2, rx466_start - sub rx466_off, rx466_pos, 1 - substr rx466_tgt, rx466_tgt, rx466_off - rx466_start: + length rx470_eos, rx470_tgt + gt rx470_pos, rx470_eos, rx470_done + set rx470_off, 0 + lt rx470_pos, 2, rx470_start + sub rx470_off, rx470_pos, 1 + substr rx470_tgt, rx470_tgt, rx470_off + rx470_start: $I10 = self.'from'() - ne $I10, -1, rxscan467_done - goto rxscan467_scan - rxscan467_loop: - ($P10) = rx466_cur."from"() + ne $I10, -1, rxscan471_done + goto rxscan471_scan + rxscan471_loop: + ($P10) = rx470_cur."from"() inc $P10 - set rx466_pos, $P10 - ge rx466_pos, rx466_eos, rxscan467_done - rxscan467_scan: - set_addr $I10, rxscan467_loop - rx466_cur."!mark_push"(0, rx466_pos, $I10) - rxscan467_done: + set rx470_pos, $P10 + ge rx470_pos, rx470_eos, rxscan471_done + rxscan471_scan: + set_addr $I10, rxscan471_loop + rx470_cur."!mark_push"(0, rx470_pos, $I10) + rxscan471_done: # rx literal ">" - add $I11, rx466_pos, 1 - gt $I11, rx466_eos, rx466_fail - sub $I11, rx466_pos, rx466_off - substr $S10, rx466_tgt, $I11, 1 - ne $S10, ">", rx466_fail - add rx466_pos, 1 + add $I11, rx470_pos, 1 + gt $I11, rx470_eos, rx470_fail + sub $I11, rx470_pos, rx470_off + substr $S10, rx470_tgt, $I11, 1 + ne $S10, ">", rx470_fail + add rx470_pos, 1 # rx pass - rx466_cur."!cursor_pass"(rx466_pos, "") - rx466_cur."!cursor_debug"("PASS ", "", " at pos=", rx466_pos) - .return (rx466_cur) - rx466_fail: - (rx466_rep, rx466_pos, $I10, $P10) = rx466_cur."!mark_fail"(0) - lt rx466_pos, -1, rx466_done - eq rx466_pos, -1, rx466_fail + rx470_cur."!cursor_pass"(rx470_pos, "") + rx470_cur."!cursor_debug"("PASS ", "", " at pos=", rx470_pos) + .return (rx470_cur) + rx470_fail: + (rx470_rep, rx470_pos, $I10, $P10) = rx470_cur."!mark_fail"(0) + lt rx470_pos, -1, rx470_done + eq rx470_pos, -1, rx470_fail jump $I10 - rx466_done: - rx466_cur."!cursor_fail"() - rx466_cur."!cursor_debug"("FAIL ", "") - .return (rx466_cur) + rx470_done: + rx470_cur."!cursor_fail"() + rx470_cur."!cursor_debug"("FAIL ", "") + .return (rx470_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "assertion:sym" :subid("133_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "assertion:sym" :subid("133_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx469_tgt - .local int rx469_pos - .local int rx469_off - .local int rx469_eos - .local int rx469_rep - .local pmc rx469_cur - (rx469_cur, rx469_pos, rx469_tgt) = self."!cursor_start"() - rx469_cur."!cursor_debug"("START ", "assertion:sym") - .lex unicode:"$\x{a2}", rx469_cur + .local string rx473_tgt + .local int rx473_pos + .local int rx473_off + .local int rx473_eos + .local int rx473_rep + .local pmc rx473_cur + (rx473_cur, rx473_pos, rx473_tgt) = self."!cursor_start"() + rx473_cur."!cursor_debug"("START ", "assertion:sym") + .lex unicode:"$\x{a2}", rx473_cur .local pmc match .lex "$/", match - length rx469_eos, rx469_tgt - gt rx469_pos, rx469_eos, rx469_done - set rx469_off, 0 - lt rx469_pos, 2, rx469_start - sub rx469_off, rx469_pos, 1 - substr rx469_tgt, rx469_tgt, rx469_off - rx469_start: + length rx473_eos, rx473_tgt + gt rx473_pos, rx473_eos, rx473_done + set rx473_off, 0 + lt rx473_pos, 2, rx473_start + sub rx473_off, rx473_pos, 1 + substr rx473_tgt, rx473_tgt, rx473_off + rx473_start: $I10 = self.'from'() - ne $I10, -1, rxscan473_done - goto rxscan473_scan - rxscan473_loop: - ($P10) = rx469_cur."from"() + ne $I10, -1, rxscan477_done + goto rxscan477_scan + rxscan477_loop: + ($P10) = rx473_cur."from"() inc $P10 - set rx469_pos, $P10 - ge rx469_pos, rx469_eos, rxscan473_done - rxscan473_scan: - set_addr $I10, rxscan473_loop - rx469_cur."!mark_push"(0, rx469_pos, $I10) - rxscan473_done: + set rx473_pos, $P10 + ge rx473_pos, rx473_eos, rxscan477_done + rxscan477_scan: + set_addr $I10, rxscan477_loop + rx473_cur."!mark_push"(0, rx473_pos, $I10) + rxscan477_done: .annotate 'line', 144 # rx literal "." - add $I11, rx469_pos, 1 - gt $I11, rx469_eos, rx469_fail - sub $I11, rx469_pos, rx469_off - substr $S10, rx469_tgt, $I11, 1 - ne $S10, ".", rx469_fail - add rx469_pos, 1 + add $I11, rx473_pos, 1 + gt $I11, rx473_eos, rx473_fail + sub $I11, rx473_pos, rx473_off + substr $S10, rx473_tgt, $I11, 1 + ne $S10, ".", rx473_fail + add rx473_pos, 1 # rx subrule "assertion" subtype=capture negate= - rx469_cur."!cursor_pos"(rx469_pos) - $P10 = rx469_cur."assertion"() - unless $P10, rx469_fail - rx469_cur."!mark_push"(0, -1, 0, $P10) + rx473_cur."!cursor_pos"(rx473_pos) + $P10 = rx473_cur."assertion"() + unless $P10, rx473_fail + rx473_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("assertion") - rx469_pos = $P10."pos"() + rx473_pos = $P10."pos"() .annotate 'line', 143 # rx pass - rx469_cur."!cursor_pass"(rx469_pos, "assertion:sym") - rx469_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx469_pos) - .return (rx469_cur) - rx469_fail: -.annotate 'line', 3 - (rx469_rep, rx469_pos, $I10, $P10) = rx469_cur."!mark_fail"(0) - lt rx469_pos, -1, rx469_done - eq rx469_pos, -1, rx469_fail + rx473_cur."!cursor_pass"(rx473_pos, "assertion:sym") + rx473_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx473_pos) + .return (rx473_cur) + rx473_fail: +.annotate 'line', 3 + (rx473_rep, rx473_pos, $I10, $P10) = rx473_cur."!mark_fail"(0) + lt rx473_pos, -1, rx473_done + eq rx473_pos, -1, rx473_fail jump $I10 - rx469_done: - rx469_cur."!cursor_fail"() - rx469_cur."!cursor_debug"("FAIL ", "assertion:sym") - .return (rx469_cur) + rx473_done: + rx473_cur."!cursor_fail"() + rx473_cur."!cursor_debug"("FAIL ", "assertion:sym") + .return (rx473_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__assertion:sym" :subid("134_1275511689.56967") :method +.sub "!PREFIX__assertion:sym" :subid("134_1275599996.35368") :method .annotate 'line', 3 - $P471 = self."!PREFIX__!subrule"("assertion", ".") - new $P472, "ResizablePMCArray" - push $P472, $P471 - .return ($P472) + $P475 = self."!PREFIX__!subrule"("assertion", ".") + new $P476, "ResizablePMCArray" + push $P476, $P475 + .return ($P476) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "assertion:sym" :subid("135_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "assertion:sym" :subid("135_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .const 'Sub' $P483 = "137_1275511689.56967" - capture_lex $P483 - .local string rx475_tgt - .local int rx475_pos - .local int rx475_off - .local int rx475_eos - .local int rx475_rep - .local pmc rx475_cur - (rx475_cur, rx475_pos, rx475_tgt) = self."!cursor_start"() - rx475_cur."!cursor_debug"("START ", "assertion:sym") - rx475_cur."!cursor_caparray"("arglist", "nibbler", "assertion") - .lex unicode:"$\x{a2}", rx475_cur + .const 'Sub' $P487 = "137_1275599996.35368" + capture_lex $P487 + .local string rx479_tgt + .local int rx479_pos + .local int rx479_off + .local int rx479_eos + .local int rx479_rep + .local pmc rx479_cur + (rx479_cur, rx479_pos, rx479_tgt) = self."!cursor_start"() + rx479_cur."!cursor_debug"("START ", "assertion:sym") + rx479_cur."!cursor_caparray"("arglist", "nibbler", "assertion") + .lex unicode:"$\x{a2}", rx479_cur .local pmc match .lex "$/", match - length rx475_eos, rx475_tgt - gt rx475_pos, rx475_eos, rx475_done - set rx475_off, 0 - lt rx475_pos, 2, rx475_start - sub rx475_off, rx475_pos, 1 - substr rx475_tgt, rx475_tgt, rx475_off - rx475_start: + length rx479_eos, rx479_tgt + gt rx479_pos, rx479_eos, rx479_done + set rx479_off, 0 + lt rx479_pos, 2, rx479_start + sub rx479_off, rx479_pos, 1 + substr rx479_tgt, rx479_tgt, rx479_off + rx479_start: $I10 = self.'from'() - ne $I10, -1, rxscan478_done - goto rxscan478_scan - rxscan478_loop: - ($P10) = rx475_cur."from"() + ne $I10, -1, rxscan482_done + goto rxscan482_scan + rxscan482_loop: + ($P10) = rx479_cur."from"() inc $P10 - set rx475_pos, $P10 - ge rx475_pos, rx475_eos, rxscan478_done - rxscan478_scan: - set_addr $I10, rxscan478_loop - rx475_cur."!mark_push"(0, rx475_pos, $I10) - rxscan478_done: + set rx479_pos, $P10 + ge rx479_pos, rx479_eos, rxscan482_done + rxscan482_scan: + set_addr $I10, rxscan482_loop + rx479_cur."!mark_push"(0, rx479_pos, $I10) + rxscan482_done: .annotate 'line', 148 # rx subcapture "longname" - set_addr $I10, rxcap_479_fail - rx475_cur."!mark_push"(0, rx475_pos, $I10) + set_addr $I10, rxcap_483_fail + rx479_cur."!mark_push"(0, rx479_pos, $I10) # rx charclass_q w r 1..-1 - sub $I10, rx475_pos, rx475_off - find_not_cclass $I11, 8192, rx475_tgt, $I10, rx475_eos + sub $I10, rx479_pos, rx479_off + find_not_cclass $I11, 8192, rx479_tgt, $I10, rx479_eos add $I12, $I10, 1 - lt $I11, $I12, rx475_fail - add rx475_pos, rx475_off, $I11 - set_addr $I10, rxcap_479_fail - ($I12, $I11) = rx475_cur."!mark_peek"($I10) - rx475_cur."!cursor_pos"($I11) - ($P10) = rx475_cur."!cursor_start"() - $P10."!cursor_pass"(rx475_pos, "") - rx475_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, $I12, rx479_fail + add rx479_pos, rx479_off, $I11 + set_addr $I10, rxcap_483_fail + ($I12, $I11) = rx479_cur."!mark_peek"($I10) + rx479_cur."!cursor_pos"($I11) + ($P10) = rx479_cur."!cursor_start"() + $P10."!cursor_pass"(rx479_pos, "") + rx479_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("longname") - goto rxcap_479_done - rxcap_479_fail: - goto rx475_fail - rxcap_479_done: + goto rxcap_483_done + rxcap_483_fail: + goto rx479_fail + rxcap_483_done: .annotate 'line', 155 - # rx rxquantr480 ** 0..1 - set_addr $I486, rxquantr480_done - rx475_cur."!mark_push"(0, rx475_pos, $I486) - rxquantr480_loop: - alt481_0: + # rx rxquantr484 ** 0..1 + set_addr $I490, rxquantr484_done + rx479_cur."!mark_push"(0, rx479_pos, $I490) + rxquantr484_loop: + alt485_0: .annotate 'line', 149 - set_addr $I10, alt481_1 - rx475_cur."!mark_push"(0, rx475_pos, $I10) + set_addr $I10, alt485_1 + rx479_cur."!mark_push"(0, rx479_pos, $I10) .annotate 'line', 150 # rx subrule "before" subtype=zerowidth negate= - rx475_cur."!cursor_pos"(rx475_pos) - .const 'Sub' $P483 = "137_1275511689.56967" - capture_lex $P483 - $P10 = rx475_cur."before"($P483) - unless $P10, rx475_fail - goto alt481_end - alt481_1: - set_addr $I10, alt481_2 - rx475_cur."!mark_push"(0, rx475_pos, $I10) + rx479_cur."!cursor_pos"(rx479_pos) + .const 'Sub' $P487 = "137_1275599996.35368" + capture_lex $P487 + $P10 = rx479_cur."before"($P487) + unless $P10, rx479_fail + goto alt485_end + alt485_1: + set_addr $I10, alt485_2 + rx479_cur."!mark_push"(0, rx479_pos, $I10) .annotate 'line', 151 # rx literal "=" - add $I11, rx475_pos, 1 - gt $I11, rx475_eos, rx475_fail - sub $I11, rx475_pos, rx475_off - substr $S10, rx475_tgt, $I11, 1 - ne $S10, "=", rx475_fail - add rx475_pos, 1 + add $I11, rx479_pos, 1 + gt $I11, rx479_eos, rx479_fail + sub $I11, rx479_pos, rx479_off + substr $S10, rx479_tgt, $I11, 1 + ne $S10, "=", rx479_fail + add rx479_pos, 1 # rx subrule "assertion" subtype=capture negate= - rx475_cur."!cursor_pos"(rx475_pos) - $P10 = rx475_cur."assertion"() - unless $P10, rx475_fail - rx475_cur."!mark_push"(0, -1, 0, $P10) + rx479_cur."!cursor_pos"(rx479_pos) + $P10 = rx479_cur."assertion"() + unless $P10, rx479_fail + rx479_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("assertion") - rx475_pos = $P10."pos"() - goto alt481_end - alt481_2: - set_addr $I10, alt481_3 - rx475_cur."!mark_push"(0, rx475_pos, $I10) + rx479_pos = $P10."pos"() + goto alt485_end + alt485_2: + set_addr $I10, alt485_3 + rx479_cur."!mark_push"(0, rx479_pos, $I10) .annotate 'line', 152 # rx literal ":" - add $I11, rx475_pos, 1 - gt $I11, rx475_eos, rx475_fail - sub $I11, rx475_pos, rx475_off - substr $S10, rx475_tgt, $I11, 1 - ne $S10, ":", rx475_fail - add rx475_pos, 1 + add $I11, rx479_pos, 1 + gt $I11, rx479_eos, rx479_fail + sub $I11, rx479_pos, rx479_off + substr $S10, rx479_tgt, $I11, 1 + ne $S10, ":", rx479_fail + add rx479_pos, 1 # rx subrule "arglist" subtype=capture negate= - rx475_cur."!cursor_pos"(rx475_pos) - $P10 = rx475_cur."arglist"() - unless $P10, rx475_fail - rx475_cur."!mark_push"(0, -1, 0, $P10) + rx479_cur."!cursor_pos"(rx479_pos) + $P10 = rx479_cur."arglist"() + unless $P10, rx479_fail + rx479_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("arglist") - rx475_pos = $P10."pos"() - goto alt481_end - alt481_3: - set_addr $I10, alt481_4 - rx475_cur."!mark_push"(0, rx475_pos, $I10) + rx479_pos = $P10."pos"() + goto alt485_end + alt485_3: + set_addr $I10, alt485_4 + rx479_cur."!mark_push"(0, rx479_pos, $I10) .annotate 'line', 153 # rx literal "(" - add $I11, rx475_pos, 1 - gt $I11, rx475_eos, rx475_fail - sub $I11, rx475_pos, rx475_off - substr $S10, rx475_tgt, $I11, 1 - ne $S10, "(", rx475_fail - add rx475_pos, 1 + add $I11, rx479_pos, 1 + gt $I11, rx479_eos, rx479_fail + sub $I11, rx479_pos, rx479_off + substr $S10, rx479_tgt, $I11, 1 + ne $S10, "(", rx479_fail + add rx479_pos, 1 # rx subrule "arglist" subtype=capture negate= - rx475_cur."!cursor_pos"(rx475_pos) - $P10 = rx475_cur."arglist"() - unless $P10, rx475_fail - rx475_cur."!mark_push"(0, -1, 0, $P10) + rx479_cur."!cursor_pos"(rx479_pos) + $P10 = rx479_cur."arglist"() + unless $P10, rx479_fail + rx479_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("arglist") - rx475_pos = $P10."pos"() + rx479_pos = $P10."pos"() # rx literal ")" - add $I11, rx475_pos, 1 - gt $I11, rx475_eos, rx475_fail - sub $I11, rx475_pos, rx475_off - substr $S10, rx475_tgt, $I11, 1 - ne $S10, ")", rx475_fail - add rx475_pos, 1 - goto alt481_end - alt481_4: + add $I11, rx479_pos, 1 + gt $I11, rx479_eos, rx479_fail + sub $I11, rx479_pos, rx479_off + substr $S10, rx479_tgt, $I11, 1 + ne $S10, ")", rx479_fail + add rx479_pos, 1 + goto alt485_end + alt485_4: .annotate 'line', 154 # rx subrule "normspace" subtype=method negate= - rx475_cur."!cursor_pos"(rx475_pos) - $P10 = rx475_cur."normspace"() - unless $P10, rx475_fail - rx475_pos = $P10."pos"() + rx479_cur."!cursor_pos"(rx479_pos) + $P10 = rx479_cur."normspace"() + unless $P10, rx479_fail + rx479_pos = $P10."pos"() # rx subrule "nibbler" subtype=capture negate= - rx475_cur."!cursor_pos"(rx475_pos) - $P10 = rx475_cur."nibbler"() - unless $P10, rx475_fail - rx475_cur."!mark_push"(0, -1, 0, $P10) + rx479_cur."!cursor_pos"(rx479_pos) + $P10 = rx479_cur."nibbler"() + unless $P10, rx479_fail + rx479_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("nibbler") - rx475_pos = $P10."pos"() - alt481_end: + rx479_pos = $P10."pos"() + alt485_end: .annotate 'line', 155 - (rx475_rep) = rx475_cur."!mark_commit"($I486) - rxquantr480_done: + (rx479_rep) = rx479_cur."!mark_commit"($I490) + rxquantr484_done: .annotate 'line', 147 # rx pass - rx475_cur."!cursor_pass"(rx475_pos, "assertion:sym") - rx475_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx475_pos) - .return (rx475_cur) - rx475_fail: -.annotate 'line', 3 - (rx475_rep, rx475_pos, $I10, $P10) = rx475_cur."!mark_fail"(0) - lt rx475_pos, -1, rx475_done - eq rx475_pos, -1, rx475_fail + rx479_cur."!cursor_pass"(rx479_pos, "assertion:sym") + rx479_cur."!cursor_debug"("PASS ", "assertion:sym", " at pos=", rx479_pos) + .return (rx479_cur) + rx479_fail: +.annotate 'line', 3 + (rx479_rep, rx479_pos, $I10, $P10) = rx479_cur."!mark_fail"(0) + lt rx479_pos, -1, rx479_done + eq rx479_pos, -1, rx479_fail jump $I10 - rx475_done: - rx475_cur."!cursor_fail"() - rx475_cur."!cursor_debug"("FAIL ", "assertion:sym") - .return (rx475_cur) + rx479_done: + rx479_cur."!cursor_fail"() + rx479_cur."!cursor_debug"("FAIL ", "assertion:sym") + .return (rx479_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__assertion:sym" :subid("136_1275511689.56967") :method +.sub "!PREFIX__assertion:sym" :subid("136_1275599996.35368") :method .annotate 'line', 3 - new $P477, "ResizablePMCArray" - push $P477, "" - .return ($P477) + new $P481, "ResizablePMCArray" + push $P481, "" + .return ($P481) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block482" :anon :subid("137_1275511689.56967") :method :outer("135_1275511689.56967") +.sub "_block486" :anon :subid("137_1275599996.35368") :method :outer("135_1275599996.35368") .annotate 'line', 150 - .local string rx484_tgt - .local int rx484_pos - .local int rx484_off - .local int rx484_eos - .local int rx484_rep - .local pmc rx484_cur - (rx484_cur, rx484_pos, rx484_tgt) = self."!cursor_start"() - rx484_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx484_cur - .local pmc match - .lex "$/", match - length rx484_eos, rx484_tgt - gt rx484_pos, rx484_eos, rx484_done - set rx484_off, 0 - lt rx484_pos, 2, rx484_start - sub rx484_off, rx484_pos, 1 - substr rx484_tgt, rx484_tgt, rx484_off - rx484_start: - $I10 = self.'from'() - ne $I10, -1, rxscan485_done - goto rxscan485_scan - rxscan485_loop: - ($P10) = rx484_cur."from"() - inc $P10 - set rx484_pos, $P10 - ge rx484_pos, rx484_eos, rxscan485_done - rxscan485_scan: - set_addr $I10, rxscan485_loop - rx484_cur."!mark_push"(0, rx484_pos, $I10) - rxscan485_done: - # rx literal ">" - add $I11, rx484_pos, 1 - gt $I11, rx484_eos, rx484_fail - sub $I11, rx484_pos, rx484_off - substr $S10, rx484_tgt, $I11, 1 - ne $S10, ">", rx484_fail - add rx484_pos, 1 - # rx pass - rx484_cur."!cursor_pass"(rx484_pos, "") - rx484_cur."!cursor_debug"("PASS ", "", " at pos=", rx484_pos) - .return (rx484_cur) - rx484_fail: - (rx484_rep, rx484_pos, $I10, $P10) = rx484_cur."!mark_fail"(0) - lt rx484_pos, -1, rx484_done - eq rx484_pos, -1, rx484_fail - jump $I10 - rx484_done: - rx484_cur."!cursor_fail"() - rx484_cur."!cursor_debug"("FAIL ", "") - .return (rx484_cur) - .return () -.end - - -.namespace ["Regex";"P6Regex";"Grammar"] -.sub "assertion:sym<[>" :subid("138_1275511689.56967") :method :outer("11_1275511689.56967") -.annotate 'line', 3 - .const 'Sub' $P493 = "140_1275511689.56967" - capture_lex $P493 .local string rx488_tgt .local int rx488_pos .local int rx488_off @@ -6044,8 +6003,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .local int rx488_rep .local pmc rx488_cur (rx488_cur, rx488_pos, rx488_tgt) = self."!cursor_start"() - rx488_cur."!cursor_debug"("START ", "assertion:sym<[>") - rx488_cur."!cursor_caparray"("cclass_elem") + rx488_cur."!cursor_debug"("START ", "") .lex unicode:"$\x{a2}", rx488_cur .local pmc match .lex "$/", match @@ -6057,547 +6015,554 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes substr rx488_tgt, rx488_tgt, rx488_off rx488_start: $I10 = self.'from'() - ne $I10, -1, rxscan491_done - goto rxscan491_scan - rxscan491_loop: + ne $I10, -1, rxscan489_done + goto rxscan489_scan + rxscan489_loop: ($P10) = rx488_cur."from"() inc $P10 set rx488_pos, $P10 - ge rx488_pos, rx488_eos, rxscan491_done - rxscan491_scan: - set_addr $I10, rxscan491_loop + ge rx488_pos, rx488_eos, rxscan489_done + rxscan489_scan: + set_addr $I10, rxscan489_loop rx488_cur."!mark_push"(0, rx488_pos, $I10) - rxscan491_done: -.annotate 'line', 158 - # rx subrule "before" subtype=zerowidth negate= - rx488_cur."!cursor_pos"(rx488_pos) - .const 'Sub' $P493 = "140_1275511689.56967" - capture_lex $P493 - $P10 = rx488_cur."before"($P493) - unless $P10, rx488_fail - # rx rxquantr497 ** 1..* - set_addr $I498, rxquantr497_done - rx488_cur."!mark_push"(0, -1, $I498) - rxquantr497_loop: - # rx subrule "cclass_elem" subtype=capture negate= - rx488_cur."!cursor_pos"(rx488_pos) - $P10 = rx488_cur."cclass_elem"() - unless $P10, rx488_fail - rx488_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"("cclass_elem") - rx488_pos = $P10."pos"() - (rx488_rep) = rx488_cur."!mark_commit"($I498) - rx488_cur."!mark_push"(rx488_rep, rx488_pos, $I498) - goto rxquantr497_loop - rxquantr497_done: + rxscan489_done: + # rx literal ">" + add $I11, rx488_pos, 1 + gt $I11, rx488_eos, rx488_fail + sub $I11, rx488_pos, rx488_off + substr $S10, rx488_tgt, $I11, 1 + ne $S10, ">", rx488_fail + add rx488_pos, 1 # rx pass - rx488_cur."!cursor_pass"(rx488_pos, "assertion:sym<[>") - rx488_cur."!cursor_debug"("PASS ", "assertion:sym<[>", " at pos=", rx488_pos) + rx488_cur."!cursor_pass"(rx488_pos, "") + rx488_cur."!cursor_debug"("PASS ", "", " at pos=", rx488_pos) .return (rx488_cur) rx488_fail: -.annotate 'line', 3 (rx488_rep, rx488_pos, $I10, $P10) = rx488_cur."!mark_fail"(0) lt rx488_pos, -1, rx488_done eq rx488_pos, -1, rx488_fail jump $I10 rx488_done: rx488_cur."!cursor_fail"() - rx488_cur."!cursor_debug"("FAIL ", "assertion:sym<[>") + rx488_cur."!cursor_debug"("FAIL ", "") .return (rx488_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__assertion:sym<[>" :subid("139_1275511689.56967") :method +.sub "assertion:sym<[>" :subid("138_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - new $P490, "ResizablePMCArray" - push $P490, "" - .return ($P490) -.end - - -.namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block492" :anon :subid("140_1275511689.56967") :method :outer("138_1275511689.56967") -.annotate 'line', 158 - .local string rx494_tgt - .local int rx494_pos - .local int rx494_off - .local int rx494_eos - .local int rx494_rep - .local pmc rx494_cur - (rx494_cur, rx494_pos, rx494_tgt) = self."!cursor_start"() - rx494_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx494_cur + .const 'Sub' $P497 = "140_1275599996.35368" + capture_lex $P497 + .local string rx492_tgt + .local int rx492_pos + .local int rx492_off + .local int rx492_eos + .local int rx492_rep + .local pmc rx492_cur + (rx492_cur, rx492_pos, rx492_tgt) = self."!cursor_start"() + rx492_cur."!cursor_debug"("START ", "assertion:sym<[>") + rx492_cur."!cursor_caparray"("cclass_elem") + .lex unicode:"$\x{a2}", rx492_cur .local pmc match .lex "$/", match - length rx494_eos, rx494_tgt - gt rx494_pos, rx494_eos, rx494_done - set rx494_off, 0 - lt rx494_pos, 2, rx494_start - sub rx494_off, rx494_pos, 1 - substr rx494_tgt, rx494_tgt, rx494_off - rx494_start: + length rx492_eos, rx492_tgt + gt rx492_pos, rx492_eos, rx492_done + set rx492_off, 0 + lt rx492_pos, 2, rx492_start + sub rx492_off, rx492_pos, 1 + substr rx492_tgt, rx492_tgt, rx492_off + rx492_start: $I10 = self.'from'() ne $I10, -1, rxscan495_done goto rxscan495_scan rxscan495_loop: - ($P10) = rx494_cur."from"() + ($P10) = rx492_cur."from"() inc $P10 - set rx494_pos, $P10 - ge rx494_pos, rx494_eos, rxscan495_done + set rx492_pos, $P10 + ge rx492_pos, rx492_eos, rxscan495_done rxscan495_scan: set_addr $I10, rxscan495_loop - rx494_cur."!mark_push"(0, rx494_pos, $I10) + rx492_cur."!mark_push"(0, rx492_pos, $I10) rxscan495_done: - alt496_0: - set_addr $I10, alt496_1 - rx494_cur."!mark_push"(0, rx494_pos, $I10) +.annotate 'line', 158 + # rx subrule "before" subtype=zerowidth negate= + rx492_cur."!cursor_pos"(rx492_pos) + .const 'Sub' $P497 = "140_1275599996.35368" + capture_lex $P497 + $P10 = rx492_cur."before"($P497) + unless $P10, rx492_fail + # rx rxquantr501 ** 1..* + set_addr $I502, rxquantr501_done + rx492_cur."!mark_push"(0, -1, $I502) + rxquantr501_loop: + # rx subrule "cclass_elem" subtype=capture negate= + rx492_cur."!cursor_pos"(rx492_pos) + $P10 = rx492_cur."cclass_elem"() + unless $P10, rx492_fail + rx492_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"("cclass_elem") + rx492_pos = $P10."pos"() + (rx492_rep) = rx492_cur."!mark_commit"($I502) + rx492_cur."!mark_push"(rx492_rep, rx492_pos, $I502) + goto rxquantr501_loop + rxquantr501_done: + # rx pass + rx492_cur."!cursor_pass"(rx492_pos, "assertion:sym<[>") + rx492_cur."!cursor_debug"("PASS ", "assertion:sym<[>", " at pos=", rx492_pos) + .return (rx492_cur) + rx492_fail: +.annotate 'line', 3 + (rx492_rep, rx492_pos, $I10, $P10) = rx492_cur."!mark_fail"(0) + lt rx492_pos, -1, rx492_done + eq rx492_pos, -1, rx492_fail + jump $I10 + rx492_done: + rx492_cur."!cursor_fail"() + rx492_cur."!cursor_debug"("FAIL ", "assertion:sym<[>") + .return (rx492_cur) + .return () +.end + + +.namespace ["Regex";"P6Regex";"Grammar"] +.sub "!PREFIX__assertion:sym<[>" :subid("139_1275599996.35368") :method +.annotate 'line', 3 + new $P494, "ResizablePMCArray" + push $P494, "" + .return ($P494) +.end + + +.namespace ["Regex";"P6Regex";"Grammar"] +.sub "_block496" :anon :subid("140_1275599996.35368") :method :outer("138_1275599996.35368") +.annotate 'line', 158 + .local string rx498_tgt + .local int rx498_pos + .local int rx498_off + .local int rx498_eos + .local int rx498_rep + .local pmc rx498_cur + (rx498_cur, rx498_pos, rx498_tgt) = self."!cursor_start"() + rx498_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx498_cur + .local pmc match + .lex "$/", match + length rx498_eos, rx498_tgt + gt rx498_pos, rx498_eos, rx498_done + set rx498_off, 0 + lt rx498_pos, 2, rx498_start + sub rx498_off, rx498_pos, 1 + substr rx498_tgt, rx498_tgt, rx498_off + rx498_start: + $I10 = self.'from'() + ne $I10, -1, rxscan499_done + goto rxscan499_scan + rxscan499_loop: + ($P10) = rx498_cur."from"() + inc $P10 + set rx498_pos, $P10 + ge rx498_pos, rx498_eos, rxscan499_done + rxscan499_scan: + set_addr $I10, rxscan499_loop + rx498_cur."!mark_push"(0, rx498_pos, $I10) + rxscan499_done: + alt500_0: + set_addr $I10, alt500_1 + rx498_cur."!mark_push"(0, rx498_pos, $I10) # rx literal "[" - add $I11, rx494_pos, 1 - gt $I11, rx494_eos, rx494_fail - sub $I11, rx494_pos, rx494_off - substr $S10, rx494_tgt, $I11, 1 - ne $S10, "[", rx494_fail - add rx494_pos, 1 - goto alt496_end - alt496_1: - set_addr $I10, alt496_2 - rx494_cur."!mark_push"(0, rx494_pos, $I10) + add $I11, rx498_pos, 1 + gt $I11, rx498_eos, rx498_fail + sub $I11, rx498_pos, rx498_off + substr $S10, rx498_tgt, $I11, 1 + ne $S10, "[", rx498_fail + add rx498_pos, 1 + goto alt500_end + alt500_1: + set_addr $I10, alt500_2 + rx498_cur."!mark_push"(0, rx498_pos, $I10) # rx literal "+" - add $I11, rx494_pos, 1 - gt $I11, rx494_eos, rx494_fail - sub $I11, rx494_pos, rx494_off - substr $S10, rx494_tgt, $I11, 1 - ne $S10, "+", rx494_fail - add rx494_pos, 1 - goto alt496_end - alt496_2: + add $I11, rx498_pos, 1 + gt $I11, rx498_eos, rx498_fail + sub $I11, rx498_pos, rx498_off + substr $S10, rx498_tgt, $I11, 1 + ne $S10, "+", rx498_fail + add rx498_pos, 1 + goto alt500_end + alt500_2: # rx literal "-" - add $I11, rx494_pos, 1 - gt $I11, rx494_eos, rx494_fail - sub $I11, rx494_pos, rx494_off - substr $S10, rx494_tgt, $I11, 1 - ne $S10, "-", rx494_fail - add rx494_pos, 1 - alt496_end: + add $I11, rx498_pos, 1 + gt $I11, rx498_eos, rx498_fail + sub $I11, rx498_pos, rx498_off + substr $S10, rx498_tgt, $I11, 1 + ne $S10, "-", rx498_fail + add rx498_pos, 1 + alt500_end: # rx pass - rx494_cur."!cursor_pass"(rx494_pos, "") - rx494_cur."!cursor_debug"("PASS ", "", " at pos=", rx494_pos) - .return (rx494_cur) - rx494_fail: - (rx494_rep, rx494_pos, $I10, $P10) = rx494_cur."!mark_fail"(0) - lt rx494_pos, -1, rx494_done - eq rx494_pos, -1, rx494_fail + rx498_cur."!cursor_pass"(rx498_pos, "") + rx498_cur."!cursor_debug"("PASS ", "", " at pos=", rx498_pos) + .return (rx498_cur) + rx498_fail: + (rx498_rep, rx498_pos, $I10, $P10) = rx498_cur."!mark_fail"(0) + lt rx498_pos, -1, rx498_done + eq rx498_pos, -1, rx498_fail jump $I10 - rx494_done: - rx494_cur."!cursor_fail"() - rx494_cur."!cursor_debug"("FAIL ", "") - .return (rx494_cur) + rx498_done: + rx498_cur."!cursor_fail"() + rx498_cur."!cursor_debug"("FAIL ", "") + .return (rx498_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "cclass_elem" :subid("141_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "cclass_elem" :subid("141_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .const 'Sub' $P511 = "143_1275511689.56967" - capture_lex $P511 - .local string rx500_tgt - .local int rx500_pos - .local int rx500_off - .local int rx500_eos - .local int rx500_rep - .local pmc rx500_cur - (rx500_cur, rx500_pos, rx500_tgt) = self."!cursor_start"() - rx500_cur."!cursor_debug"("START ", "cclass_elem") - rx500_cur."!cursor_caparray"("charspec") - .lex unicode:"$\x{a2}", rx500_cur + .const 'Sub' $P515 = "143_1275599996.35368" + capture_lex $P515 + .local string rx504_tgt + .local int rx504_pos + .local int rx504_off + .local int rx504_eos + .local int rx504_rep + .local pmc rx504_cur + (rx504_cur, rx504_pos, rx504_tgt) = self."!cursor_start"() + rx504_cur."!cursor_debug"("START ", "cclass_elem") + rx504_cur."!cursor_caparray"("charspec") + .lex unicode:"$\x{a2}", rx504_cur .local pmc match .lex "$/", match - length rx500_eos, rx500_tgt - gt rx500_pos, rx500_eos, rx500_done - set rx500_off, 0 - lt rx500_pos, 2, rx500_start - sub rx500_off, rx500_pos, 1 - substr rx500_tgt, rx500_tgt, rx500_off - rx500_start: + length rx504_eos, rx504_tgt + gt rx504_pos, rx504_eos, rx504_done + set rx504_off, 0 + lt rx504_pos, 2, rx504_start + sub rx504_off, rx504_pos, 1 + substr rx504_tgt, rx504_tgt, rx504_off + rx504_start: $I10 = self.'from'() - ne $I10, -1, rxscan503_done - goto rxscan503_scan - rxscan503_loop: - ($P10) = rx500_cur."from"() + ne $I10, -1, rxscan507_done + goto rxscan507_scan + rxscan507_loop: + ($P10) = rx504_cur."from"() inc $P10 - set rx500_pos, $P10 - ge rx500_pos, rx500_eos, rxscan503_done - rxscan503_scan: - set_addr $I10, rxscan503_loop - rx500_cur."!mark_push"(0, rx500_pos, $I10) - rxscan503_done: + set rx504_pos, $P10 + ge rx504_pos, rx504_eos, rxscan507_done + rxscan507_scan: + set_addr $I10, rxscan507_loop + rx504_cur."!mark_push"(0, rx504_pos, $I10) + rxscan507_done: .annotate 'line', 161 # rx subcapture "sign" - set_addr $I10, rxcap_505_fail - rx500_cur."!mark_push"(0, rx500_pos, $I10) - alt504_0: - set_addr $I10, alt504_1 - rx500_cur."!mark_push"(0, rx500_pos, $I10) + set_addr $I10, rxcap_509_fail + rx504_cur."!mark_push"(0, rx504_pos, $I10) + alt508_0: + set_addr $I10, alt508_1 + rx504_cur."!mark_push"(0, rx504_pos, $I10) # rx literal "+" - add $I11, rx500_pos, 1 - gt $I11, rx500_eos, rx500_fail - sub $I11, rx500_pos, rx500_off - substr $S10, rx500_tgt, $I11, 1 - ne $S10, "+", rx500_fail - add rx500_pos, 1 - goto alt504_end - alt504_1: - set_addr $I10, alt504_2 - rx500_cur."!mark_push"(0, rx500_pos, $I10) + add $I11, rx504_pos, 1 + gt $I11, rx504_eos, rx504_fail + sub $I11, rx504_pos, rx504_off + substr $S10, rx504_tgt, $I11, 1 + ne $S10, "+", rx504_fail + add rx504_pos, 1 + goto alt508_end + alt508_1: + set_addr $I10, alt508_2 + rx504_cur."!mark_push"(0, rx504_pos, $I10) # rx literal "-" - add $I11, rx500_pos, 1 - gt $I11, rx500_eos, rx500_fail - sub $I11, rx500_pos, rx500_off - substr $S10, rx500_tgt, $I11, 1 - ne $S10, "-", rx500_fail - add rx500_pos, 1 - goto alt504_end - alt504_2: - alt504_end: - set_addr $I10, rxcap_505_fail - ($I12, $I11) = rx500_cur."!mark_peek"($I10) - rx500_cur."!cursor_pos"($I11) - ($P10) = rx500_cur."!cursor_start"() - $P10."!cursor_pass"(rx500_pos, "") - rx500_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx504_pos, 1 + gt $I11, rx504_eos, rx504_fail + sub $I11, rx504_pos, rx504_off + substr $S10, rx504_tgt, $I11, 1 + ne $S10, "-", rx504_fail + add rx504_pos, 1 + goto alt508_end + alt508_2: + alt508_end: + set_addr $I10, rxcap_509_fail + ($I12, $I11) = rx504_cur."!mark_peek"($I10) + rx504_cur."!cursor_pos"($I11) + ($P10) = rx504_cur."!cursor_start"() + $P10."!cursor_pass"(rx504_pos, "") + rx504_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sign") - goto rxcap_505_done - rxcap_505_fail: - goto rx500_fail - rxcap_505_done: + goto rxcap_509_done + rxcap_509_fail: + goto rx504_fail + rxcap_509_done: .annotate 'line', 162 - # rx rxquantr506 ** 0..1 - set_addr $I507, rxquantr506_done - rx500_cur."!mark_push"(0, rx500_pos, $I507) - rxquantr506_loop: + # rx rxquantr510 ** 0..1 + set_addr $I511, rxquantr510_done + rx504_cur."!mark_push"(0, rx504_pos, $I511) + rxquantr510_loop: # rx subrule "normspace" subtype=method negate= - rx500_cur."!cursor_pos"(rx500_pos) - $P10 = rx500_cur."normspace"() - unless $P10, rx500_fail - rx500_pos = $P10."pos"() - (rx500_rep) = rx500_cur."!mark_commit"($I507) - rxquantr506_done: - alt508_0: + rx504_cur."!cursor_pos"(rx504_pos) + $P10 = rx504_cur."normspace"() + unless $P10, rx504_fail + rx504_pos = $P10."pos"() + (rx504_rep) = rx504_cur."!mark_commit"($I511) + rxquantr510_done: + alt512_0: .annotate 'line', 163 - set_addr $I10, alt508_1 - rx500_cur."!mark_push"(0, rx500_pos, $I10) + set_addr $I10, alt512_1 + rx504_cur."!mark_push"(0, rx504_pos, $I10) .annotate 'line', 164 # rx literal "[" - add $I11, rx500_pos, 1 - gt $I11, rx500_eos, rx500_fail - sub $I11, rx500_pos, rx500_off - substr $S10, rx500_tgt, $I11, 1 - ne $S10, "[", rx500_fail - add rx500_pos, 1 + add $I11, rx504_pos, 1 + gt $I11, rx504_eos, rx504_fail + sub $I11, rx504_pos, rx504_off + substr $S10, rx504_tgt, $I11, 1 + ne $S10, "[", rx504_fail + add rx504_pos, 1 .annotate 'line', 167 - # rx rxquantr509 ** 0..* - set_addr $I530, rxquantr509_done - rx500_cur."!mark_push"(0, rx500_pos, $I530) - rxquantr509_loop: + # rx rxquantr513 ** 0..* + set_addr $I534, rxquantr513_done + rx504_cur."!mark_push"(0, rx504_pos, $I534) + rxquantr513_loop: .annotate 'line', 164 - # rx subrule $P511 subtype=capture negate= - rx500_cur."!cursor_pos"(rx500_pos) - .const 'Sub' $P511 = "143_1275511689.56967" - capture_lex $P511 - $P10 = rx500_cur.$P511() - unless $P10, rx500_fail - rx500_cur."!mark_push"(0, -1, 0, $P10) + # rx subrule $P515 subtype=capture negate= + rx504_cur."!cursor_pos"(rx504_pos) + .const 'Sub' $P515 = "143_1275599996.35368" + capture_lex $P515 + $P10 = rx504_cur.$P515() + unless $P10, rx504_fail + rx504_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("charspec") - rx500_pos = $P10."pos"() + rx504_pos = $P10."pos"() .annotate 'line', 167 - (rx500_rep) = rx500_cur."!mark_commit"($I530) - rx500_cur."!mark_push"(rx500_rep, rx500_pos, $I530) - goto rxquantr509_loop - rxquantr509_done: + (rx504_rep) = rx504_cur."!mark_commit"($I534) + rx504_cur."!mark_push"(rx504_rep, rx504_pos, $I534) + goto rxquantr513_loop + rxquantr513_done: .annotate 'line', 168 # rx charclass_q s r 0..-1 - sub $I10, rx500_pos, rx500_off - find_not_cclass $I11, 32, rx500_tgt, $I10, rx500_eos - add rx500_pos, rx500_off, $I11 + sub $I10, rx504_pos, rx504_off + find_not_cclass $I11, 32, rx504_tgt, $I10, rx504_eos + add rx504_pos, rx504_off, $I11 # rx literal "]" - add $I11, rx500_pos, 1 - gt $I11, rx500_eos, rx500_fail - sub $I11, rx500_pos, rx500_off - substr $S10, rx500_tgt, $I11, 1 - ne $S10, "]", rx500_fail - add rx500_pos, 1 + add $I11, rx504_pos, 1 + gt $I11, rx504_eos, rx504_fail + sub $I11, rx504_pos, rx504_off + substr $S10, rx504_tgt, $I11, 1 + ne $S10, "]", rx504_fail + add rx504_pos, 1 .annotate 'line', 164 - goto alt508_end - alt508_1: + goto alt512_end + alt512_1: .annotate 'line', 169 # rx subcapture "name" - set_addr $I10, rxcap_531_fail - rx500_cur."!mark_push"(0, rx500_pos, $I10) + set_addr $I10, rxcap_535_fail + rx504_cur."!mark_push"(0, rx504_pos, $I10) # rx charclass_q w r 1..-1 - sub $I10, rx500_pos, rx500_off - find_not_cclass $I11, 8192, rx500_tgt, $I10, rx500_eos + sub $I10, rx504_pos, rx504_off + find_not_cclass $I11, 8192, rx504_tgt, $I10, rx504_eos add $I12, $I10, 1 - lt $I11, $I12, rx500_fail - add rx500_pos, rx500_off, $I11 - set_addr $I10, rxcap_531_fail - ($I12, $I11) = rx500_cur."!mark_peek"($I10) - rx500_cur."!cursor_pos"($I11) - ($P10) = rx500_cur."!cursor_start"() - $P10."!cursor_pass"(rx500_pos, "") - rx500_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, $I12, rx504_fail + add rx504_pos, rx504_off, $I11 + set_addr $I10, rxcap_535_fail + ($I12, $I11) = rx504_cur."!mark_peek"($I10) + rx504_cur."!cursor_pos"($I11) + ($P10) = rx504_cur."!cursor_start"() + $P10."!cursor_pass"(rx504_pos, "") + rx504_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("name") - goto rxcap_531_done - rxcap_531_fail: - goto rx500_fail - rxcap_531_done: - alt508_end: + goto rxcap_535_done + rxcap_535_fail: + goto rx504_fail + rxcap_535_done: + alt512_end: .annotate 'line', 171 - # rx rxquantr532 ** 0..1 - set_addr $I533, rxquantr532_done - rx500_cur."!mark_push"(0, rx500_pos, $I533) - rxquantr532_loop: + # rx rxquantr536 ** 0..1 + set_addr $I537, rxquantr536_done + rx504_cur."!mark_push"(0, rx504_pos, $I537) + rxquantr536_loop: # rx subrule "normspace" subtype=method negate= - rx500_cur."!cursor_pos"(rx500_pos) - $P10 = rx500_cur."normspace"() - unless $P10, rx500_fail - rx500_pos = $P10."pos"() - (rx500_rep) = rx500_cur."!mark_commit"($I533) - rxquantr532_done: + rx504_cur."!cursor_pos"(rx504_pos) + $P10 = rx504_cur."normspace"() + unless $P10, rx504_fail + rx504_pos = $P10."pos"() + (rx504_rep) = rx504_cur."!mark_commit"($I537) + rxquantr536_done: .annotate 'line', 160 # rx pass - rx500_cur."!cursor_pass"(rx500_pos, "cclass_elem") - rx500_cur."!cursor_debug"("PASS ", "cclass_elem", " at pos=", rx500_pos) - .return (rx500_cur) - rx500_fail: -.annotate 'line', 3 - (rx500_rep, rx500_pos, $I10, $P10) = rx500_cur."!mark_fail"(0) - lt rx500_pos, -1, rx500_done - eq rx500_pos, -1, rx500_fail + rx504_cur."!cursor_pass"(rx504_pos, "cclass_elem") + rx504_cur."!cursor_debug"("PASS ", "cclass_elem", " at pos=", rx504_pos) + .return (rx504_cur) + rx504_fail: +.annotate 'line', 3 + (rx504_rep, rx504_pos, $I10, $P10) = rx504_cur."!mark_fail"(0) + lt rx504_pos, -1, rx504_done + eq rx504_pos, -1, rx504_fail jump $I10 - rx500_done: - rx500_cur."!cursor_fail"() - rx500_cur."!cursor_debug"("FAIL ", "cclass_elem") - .return (rx500_cur) + rx504_done: + rx504_cur."!cursor_fail"() + rx504_cur."!cursor_debug"("FAIL ", "cclass_elem") + .return (rx504_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__cclass_elem" :subid("142_1275511689.56967") :method +.sub "!PREFIX__cclass_elem" :subid("142_1275599996.35368") :method .annotate 'line', 3 - new $P502, "ResizablePMCArray" - push $P502, "" - push $P502, "-" - push $P502, "+" - .return ($P502) + new $P506, "ResizablePMCArray" + push $P506, "" + push $P506, "-" + push $P506, "+" + .return ($P506) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block510" :anon :subid("143_1275511689.56967") :method :outer("141_1275511689.56967") +.sub "_block514" :anon :subid("143_1275599996.35368") :method :outer("141_1275599996.35368") .annotate 'line', 164 - .const 'Sub' $P526 = "146_1275511689.56967" - capture_lex $P526 - .const 'Sub' $P521 = "145_1275511689.56967" + .const 'Sub' $P530 = "146_1275599996.35368" + capture_lex $P530 + .const 'Sub' $P525 = "145_1275599996.35368" + capture_lex $P525 + .const 'Sub' $P521 = "144_1275599996.35368" capture_lex $P521 - .const 'Sub' $P517 = "144_1275511689.56967" - capture_lex $P517 - .local string rx512_tgt - .local int rx512_pos - .local int rx512_off - .local int rx512_eos - .local int rx512_rep - .local pmc rx512_cur - (rx512_cur, rx512_pos, rx512_tgt) = self."!cursor_start"() - rx512_cur."!cursor_debug"("START ", "") - rx512_cur."!cursor_caparray"("1") - .lex unicode:"$\x{a2}", rx512_cur + .local string rx516_tgt + .local int rx516_pos + .local int rx516_off + .local int rx516_eos + .local int rx516_rep + .local pmc rx516_cur + (rx516_cur, rx516_pos, rx516_tgt) = self."!cursor_start"() + rx516_cur."!cursor_debug"("START ", "") + rx516_cur."!cursor_caparray"("1") + .lex unicode:"$\x{a2}", rx516_cur .local pmc match .lex "$/", match - length rx512_eos, rx512_tgt - gt rx512_pos, rx512_eos, rx512_done - set rx512_off, 0 - lt rx512_pos, 2, rx512_start - sub rx512_off, rx512_pos, 1 - substr rx512_tgt, rx512_tgt, rx512_off - rx512_start: + length rx516_eos, rx516_tgt + gt rx516_pos, rx516_eos, rx516_done + set rx516_off, 0 + lt rx516_pos, 2, rx516_start + sub rx516_off, rx516_pos, 1 + substr rx516_tgt, rx516_tgt, rx516_off + rx516_start: $I10 = self.'from'() - ne $I10, -1, rxscan513_done - goto rxscan513_scan - rxscan513_loop: - ($P10) = rx512_cur."from"() + ne $I10, -1, rxscan517_done + goto rxscan517_scan + rxscan517_loop: + ($P10) = rx516_cur."from"() inc $P10 - set rx512_pos, $P10 - ge rx512_pos, rx512_eos, rxscan513_done - rxscan513_scan: - set_addr $I10, rxscan513_loop - rx512_cur."!mark_push"(0, rx512_pos, $I10) - rxscan513_done: - alt514_0: - set_addr $I10, alt514_1 - rx512_cur."!mark_push"(0, rx512_pos, $I10) + set rx516_pos, $P10 + ge rx516_pos, rx516_eos, rxscan517_done + rxscan517_scan: + set_addr $I10, rxscan517_loop + rx516_cur."!mark_push"(0, rx516_pos, $I10) + rxscan517_done: + alt518_0: + set_addr $I10, alt518_1 + rx516_cur."!mark_push"(0, rx516_pos, $I10) .annotate 'line', 165 # rx charclass_q s r 0..-1 - sub $I10, rx512_pos, rx512_off - find_not_cclass $I11, 32, rx512_tgt, $I10, rx512_eos - add rx512_pos, rx512_off, $I11 + sub $I10, rx516_pos, rx516_off + find_not_cclass $I11, 32, rx516_tgt, $I10, rx516_eos + add rx516_pos, rx516_off, $I11 # rx literal "-" - add $I11, rx512_pos, 1 - gt $I11, rx512_eos, rx512_fail - sub $I11, rx512_pos, rx512_off - substr $S10, rx512_tgt, $I11, 1 - ne $S10, "-", rx512_fail - add rx512_pos, 1 + add $I11, rx516_pos, 1 + gt $I11, rx516_eos, rx516_fail + sub $I11, rx516_pos, rx516_off + substr $S10, rx516_tgt, $I11, 1 + ne $S10, "-", rx516_fail + add rx516_pos, 1 # rx subrule "obs" subtype=method negate= - rx512_cur."!cursor_pos"(rx512_pos) - $P10 = rx512_cur."obs"("hyphen in enumerated character class", "..") - unless $P10, rx512_fail - rx512_pos = $P10."pos"() - goto alt514_end - alt514_1: + rx516_cur."!cursor_pos"(rx516_pos) + $P10 = rx516_cur."obs"("hyphen in enumerated character class", "..") + unless $P10, rx516_fail + rx516_pos = $P10."pos"() + goto alt518_end + alt518_1: .annotate 'line', 166 # rx charclass_q s r 0..-1 - sub $I10, rx512_pos, rx512_off - find_not_cclass $I11, 32, rx512_tgt, $I10, rx512_eos - add rx512_pos, rx512_off, $I11 - alt515_0: - set_addr $I10, alt515_1 - rx512_cur."!mark_push"(0, rx512_pos, $I10) + sub $I10, rx516_pos, rx516_off + find_not_cclass $I11, 32, rx516_tgt, $I10, rx516_eos + add rx516_pos, rx516_off, $I11 + alt519_0: + set_addr $I10, alt519_1 + rx516_cur."!mark_push"(0, rx516_pos, $I10) # rx literal "\\" - add $I11, rx512_pos, 1 - gt $I11, rx512_eos, rx512_fail - sub $I11, rx512_pos, rx512_off - substr $S10, rx512_tgt, $I11, 1 - ne $S10, "\\", rx512_fail - add rx512_pos, 1 - # rx subrule $P517 subtype=capture negate= - rx512_cur."!cursor_pos"(rx512_pos) - .const 'Sub' $P517 = "144_1275511689.56967" - capture_lex $P517 - $P10 = rx512_cur.$P517() - unless $P10, rx512_fail - rx512_cur."!mark_push"(0, -1, 0, $P10) - $P10."!cursor_names"(0) - rx512_pos = $P10."pos"() - goto alt515_end - alt515_1: + add $I11, rx516_pos, 1 + gt $I11, rx516_eos, rx516_fail + sub $I11, rx516_pos, rx516_off + substr $S10, rx516_tgt, $I11, 1 + ne $S10, "\\", rx516_fail + add rx516_pos, 1 # rx subrule $P521 subtype=capture negate= - rx512_cur."!cursor_pos"(rx512_pos) - .const 'Sub' $P521 = "145_1275511689.56967" + rx516_cur."!cursor_pos"(rx516_pos) + .const 'Sub' $P521 = "144_1275599996.35368" capture_lex $P521 - $P10 = rx512_cur.$P521() - unless $P10, rx512_fail - rx512_cur."!mark_push"(0, -1, 0, $P10) + $P10 = rx516_cur.$P521() + unless $P10, rx516_fail + rx516_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"(0) - rx512_pos = $P10."pos"() - alt515_end: - # rx rxquantr524 ** 0..1 - set_addr $I529, rxquantr524_done - rx512_cur."!mark_push"(0, rx512_pos, $I529) - rxquantr524_loop: + rx516_pos = $P10."pos"() + goto alt519_end + alt519_1: + # rx subrule $P525 subtype=capture negate= + rx516_cur."!cursor_pos"(rx516_pos) + .const 'Sub' $P525 = "145_1275599996.35368" + capture_lex $P525 + $P10 = rx516_cur.$P525() + unless $P10, rx516_fail + rx516_cur."!mark_push"(0, -1, 0, $P10) + $P10."!cursor_names"(0) + rx516_pos = $P10."pos"() + alt519_end: + # rx rxquantr528 ** 0..1 + set_addr $I533, rxquantr528_done + rx516_cur."!mark_push"(0, rx516_pos, $I533) + rxquantr528_loop: # rx charclass_q s r 0..-1 - sub $I10, rx512_pos, rx512_off - find_not_cclass $I11, 32, rx512_tgt, $I10, rx512_eos - add rx512_pos, rx512_off, $I11 + sub $I10, rx516_pos, rx516_off + find_not_cclass $I11, 32, rx516_tgt, $I10, rx516_eos + add rx516_pos, rx516_off, $I11 # rx literal ".." - add $I11, rx512_pos, 2 - gt $I11, rx512_eos, rx512_fail - sub $I11, rx512_pos, rx512_off - substr $S10, rx512_tgt, $I11, 2 - ne $S10, "..", rx512_fail - add rx512_pos, 2 + add $I11, rx516_pos, 2 + gt $I11, rx516_eos, rx516_fail + sub $I11, rx516_pos, rx516_off + substr $S10, rx516_tgt, $I11, 2 + ne $S10, "..", rx516_fail + add rx516_pos, 2 # rx charclass_q s r 0..-1 - sub $I10, rx512_pos, rx512_off - find_not_cclass $I11, 32, rx512_tgt, $I10, rx512_eos - add rx512_pos, rx512_off, $I11 - # rx subrule $P526 subtype=capture negate= - rx512_cur."!cursor_pos"(rx512_pos) - .const 'Sub' $P526 = "146_1275511689.56967" - capture_lex $P526 - $P10 = rx512_cur.$P526() - unless $P10, rx512_fail - rx512_cur."!mark_push"(0, -1, 0, $P10) + sub $I10, rx516_pos, rx516_off + find_not_cclass $I11, 32, rx516_tgt, $I10, rx516_eos + add rx516_pos, rx516_off, $I11 + # rx subrule $P530 subtype=capture negate= + rx516_cur."!cursor_pos"(rx516_pos) + .const 'Sub' $P530 = "146_1275599996.35368" + capture_lex $P530 + $P10 = rx516_cur.$P530() + unless $P10, rx516_fail + rx516_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("1") - rx512_pos = $P10."pos"() - (rx512_rep) = rx512_cur."!mark_commit"($I529) - rxquantr524_done: - alt514_end: + rx516_pos = $P10."pos"() + (rx516_rep) = rx516_cur."!mark_commit"($I533) + rxquantr528_done: + alt518_end: .annotate 'line', 164 # rx pass - rx512_cur."!cursor_pass"(rx512_pos, "") - rx512_cur."!cursor_debug"("PASS ", "", " at pos=", rx512_pos) - .return (rx512_cur) - rx512_fail: - (rx512_rep, rx512_pos, $I10, $P10) = rx512_cur."!mark_fail"(0) - lt rx512_pos, -1, rx512_done - eq rx512_pos, -1, rx512_fail - jump $I10 - rx512_done: - rx512_cur."!cursor_fail"() - rx512_cur."!cursor_debug"("FAIL ", "") - .return (rx512_cur) - .return () -.end - - -.namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block516" :anon :subid("144_1275511689.56967") :method :outer("143_1275511689.56967") -.annotate 'line', 166 - .local string rx518_tgt - .local int rx518_pos - .local int rx518_off - .local int rx518_eos - .local int rx518_rep - .local pmc rx518_cur - (rx518_cur, rx518_pos, rx518_tgt) = self."!cursor_start"() - rx518_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx518_cur - .local pmc match - .lex "$/", match - length rx518_eos, rx518_tgt - gt rx518_pos, rx518_eos, rx518_done - set rx518_off, 0 - lt rx518_pos, 2, rx518_start - sub rx518_off, rx518_pos, 1 - substr rx518_tgt, rx518_tgt, rx518_off - rx518_start: - $I10 = self.'from'() - ne $I10, -1, rxscan519_done - goto rxscan519_scan - rxscan519_loop: - ($P10) = rx518_cur."from"() - inc $P10 - set rx518_pos, $P10 - ge rx518_pos, rx518_eos, rxscan519_done - rxscan519_scan: - set_addr $I10, rxscan519_loop - rx518_cur."!mark_push"(0, rx518_pos, $I10) - rxscan519_done: - # rx charclass . - ge rx518_pos, rx518_eos, rx518_fail - inc rx518_pos - # rx pass - rx518_cur."!cursor_pass"(rx518_pos, "") - rx518_cur."!cursor_debug"("PASS ", "", " at pos=", rx518_pos) - .return (rx518_cur) - rx518_fail: - (rx518_rep, rx518_pos, $I10, $P10) = rx518_cur."!mark_fail"(0) - lt rx518_pos, -1, rx518_done - eq rx518_pos, -1, rx518_fail + rx516_cur."!cursor_pass"(rx516_pos, "") + rx516_cur."!cursor_debug"("PASS ", "", " at pos=", rx516_pos) + .return (rx516_cur) + rx516_fail: + (rx516_rep, rx516_pos, $I10, $P10) = rx516_cur."!mark_fail"(0) + lt rx516_pos, -1, rx516_done + eq rx516_pos, -1, rx516_fail jump $I10 - rx518_done: - rx518_cur."!cursor_fail"() - rx518_cur."!cursor_debug"("FAIL ", "") - .return (rx518_cur) + rx516_done: + rx516_cur."!cursor_fail"() + rx516_cur."!cursor_debug"("FAIL ", "") + .return (rx516_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block520" :anon :subid("145_1275511689.56967") :method :outer("143_1275511689.56967") +.sub "_block520" :anon :subid("144_1275599996.35368") :method :outer("143_1275599996.35368") .annotate 'line', 166 .local string rx522_tgt .local int rx522_pos @@ -6629,12 +6594,8 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes set_addr $I10, rxscan523_loop rx522_cur."!mark_push"(0, rx522_pos, $I10) rxscan523_done: - # rx enumcharlist negate=1 + # rx charclass . ge rx522_pos, rx522_eos, rx522_fail - sub $I10, rx522_pos, rx522_off - substr $S10, rx522_tgt, $I10, 1 - index $I11, "]\\", $S10 - ge $I11, 0, rx522_fail inc rx522_pos # rx pass rx522_cur."!cursor_pass"(rx522_pos, "") @@ -6654,615 +6615,672 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block525" :anon :subid("146_1275511689.56967") :method :outer("143_1275511689.56967") +.sub "_block524" :anon :subid("145_1275599996.35368") :method :outer("143_1275599996.35368") +.annotate 'line', 166 + .local string rx526_tgt + .local int rx526_pos + .local int rx526_off + .local int rx526_eos + .local int rx526_rep + .local pmc rx526_cur + (rx526_cur, rx526_pos, rx526_tgt) = self."!cursor_start"() + rx526_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx526_cur + .local pmc match + .lex "$/", match + length rx526_eos, rx526_tgt + gt rx526_pos, rx526_eos, rx526_done + set rx526_off, 0 + lt rx526_pos, 2, rx526_start + sub rx526_off, rx526_pos, 1 + substr rx526_tgt, rx526_tgt, rx526_off + rx526_start: + $I10 = self.'from'() + ne $I10, -1, rxscan527_done + goto rxscan527_scan + rxscan527_loop: + ($P10) = rx526_cur."from"() + inc $P10 + set rx526_pos, $P10 + ge rx526_pos, rx526_eos, rxscan527_done + rxscan527_scan: + set_addr $I10, rxscan527_loop + rx526_cur."!mark_push"(0, rx526_pos, $I10) + rxscan527_done: + # rx enumcharlist negate=1 + ge rx526_pos, rx526_eos, rx526_fail + sub $I10, rx526_pos, rx526_off + substr $S10, rx526_tgt, $I10, 1 + index $I11, "]\\", $S10 + ge $I11, 0, rx526_fail + inc rx526_pos + # rx pass + rx526_cur."!cursor_pass"(rx526_pos, "") + rx526_cur."!cursor_debug"("PASS ", "", " at pos=", rx526_pos) + .return (rx526_cur) + rx526_fail: + (rx526_rep, rx526_pos, $I10, $P10) = rx526_cur."!mark_fail"(0) + lt rx526_pos, -1, rx526_done + eq rx526_pos, -1, rx526_fail + jump $I10 + rx526_done: + rx526_cur."!cursor_fail"() + rx526_cur."!cursor_debug"("FAIL ", "") + .return (rx526_cur) + .return () +.end + + +.namespace ["Regex";"P6Regex";"Grammar"] +.sub "_block529" :anon :subid("146_1275599996.35368") :method :outer("143_1275599996.35368") .annotate 'line', 166 - .local string rx527_tgt - .local int rx527_pos - .local int rx527_off - .local int rx527_eos - .local int rx527_rep - .local pmc rx527_cur - (rx527_cur, rx527_pos, rx527_tgt) = self."!cursor_start"() - rx527_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx527_cur + .local string rx531_tgt + .local int rx531_pos + .local int rx531_off + .local int rx531_eos + .local int rx531_rep + .local pmc rx531_cur + (rx531_cur, rx531_pos, rx531_tgt) = self."!cursor_start"() + rx531_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx531_cur .local pmc match .lex "$/", match - length rx527_eos, rx527_tgt - gt rx527_pos, rx527_eos, rx527_done - set rx527_off, 0 - lt rx527_pos, 2, rx527_start - sub rx527_off, rx527_pos, 1 - substr rx527_tgt, rx527_tgt, rx527_off - rx527_start: + length rx531_eos, rx531_tgt + gt rx531_pos, rx531_eos, rx531_done + set rx531_off, 0 + lt rx531_pos, 2, rx531_start + sub rx531_off, rx531_pos, 1 + substr rx531_tgt, rx531_tgt, rx531_off + rx531_start: $I10 = self.'from'() - ne $I10, -1, rxscan528_done - goto rxscan528_scan - rxscan528_loop: - ($P10) = rx527_cur."from"() + ne $I10, -1, rxscan532_done + goto rxscan532_scan + rxscan532_loop: + ($P10) = rx531_cur."from"() inc $P10 - set rx527_pos, $P10 - ge rx527_pos, rx527_eos, rxscan528_done - rxscan528_scan: - set_addr $I10, rxscan528_loop - rx527_cur."!mark_push"(0, rx527_pos, $I10) - rxscan528_done: + set rx531_pos, $P10 + ge rx531_pos, rx531_eos, rxscan532_done + rxscan532_scan: + set_addr $I10, rxscan532_loop + rx531_cur."!mark_push"(0, rx531_pos, $I10) + rxscan532_done: # rx charclass . - ge rx527_pos, rx527_eos, rx527_fail - inc rx527_pos + ge rx531_pos, rx531_eos, rx531_fail + inc rx531_pos # rx pass - rx527_cur."!cursor_pass"(rx527_pos, "") - rx527_cur."!cursor_debug"("PASS ", "", " at pos=", rx527_pos) - .return (rx527_cur) - rx527_fail: - (rx527_rep, rx527_pos, $I10, $P10) = rx527_cur."!mark_fail"(0) - lt rx527_pos, -1, rx527_done - eq rx527_pos, -1, rx527_fail + rx531_cur."!cursor_pass"(rx531_pos, "") + rx531_cur."!cursor_debug"("PASS ", "", " at pos=", rx531_pos) + .return (rx531_cur) + rx531_fail: + (rx531_rep, rx531_pos, $I10, $P10) = rx531_cur."!mark_fail"(0) + lt rx531_pos, -1, rx531_done + eq rx531_pos, -1, rx531_fail jump $I10 - rx527_done: - rx527_cur."!cursor_fail"() - rx527_cur."!cursor_debug"("FAIL ", "") - .return (rx527_cur) + rx531_done: + rx531_cur."!cursor_fail"() + rx531_cur."!cursor_debug"("FAIL ", "") + .return (rx531_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "mod_internal" :subid("147_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "mod_internal" :subid("147_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .const 'Sub' $P543 = "149_1275511689.56967" - capture_lex $P543 - .local string rx535_tgt - .local int rx535_pos - .local int rx535_off - .local int rx535_eos - .local int rx535_rep - .local pmc rx535_cur - (rx535_cur, rx535_pos, rx535_tgt) = self."!cursor_start"() - rx535_cur."!cursor_debug"("START ", "mod_internal") - rx535_cur."!cursor_caparray"("n") - .lex unicode:"$\x{a2}", rx535_cur + .const 'Sub' $P547 = "149_1275599996.35368" + capture_lex $P547 + .local string rx539_tgt + .local int rx539_pos + .local int rx539_off + .local int rx539_eos + .local int rx539_rep + .local pmc rx539_cur + (rx539_cur, rx539_pos, rx539_tgt) = self."!cursor_start"() + rx539_cur."!cursor_debug"("START ", "mod_internal") + rx539_cur."!cursor_caparray"("n") + .lex unicode:"$\x{a2}", rx539_cur .local pmc match .lex "$/", match - length rx535_eos, rx535_tgt - gt rx535_pos, rx535_eos, rx535_done - set rx535_off, 0 - lt rx535_pos, 2, rx535_start - sub rx535_off, rx535_pos, 1 - substr rx535_tgt, rx535_tgt, rx535_off - rx535_start: + length rx539_eos, rx539_tgt + gt rx539_pos, rx539_eos, rx539_done + set rx539_off, 0 + lt rx539_pos, 2, rx539_start + sub rx539_off, rx539_pos, 1 + substr rx539_tgt, rx539_tgt, rx539_off + rx539_start: $I10 = self.'from'() - ne $I10, -1, rxscan539_done - goto rxscan539_scan - rxscan539_loop: - ($P10) = rx535_cur."from"() + ne $I10, -1, rxscan543_done + goto rxscan543_scan + rxscan543_loop: + ($P10) = rx539_cur."from"() inc $P10 - set rx535_pos, $P10 - ge rx535_pos, rx535_eos, rxscan539_done - rxscan539_scan: - set_addr $I10, rxscan539_loop - rx535_cur."!mark_push"(0, rx535_pos, $I10) - rxscan539_done: - alt540_0: + set rx539_pos, $P10 + ge rx539_pos, rx539_eos, rxscan543_done + rxscan543_scan: + set_addr $I10, rxscan543_loop + rx539_cur."!mark_push"(0, rx539_pos, $I10) + rxscan543_done: + alt544_0: .annotate 'line', 175 - set_addr $I10, alt540_1 - rx535_cur."!mark_push"(0, rx535_pos, $I10) + set_addr $I10, alt544_1 + rx539_cur."!mark_push"(0, rx539_pos, $I10) .annotate 'line', 176 # rx literal ":" - add $I11, rx535_pos, 1 - gt $I11, rx535_eos, rx535_fail - sub $I11, rx535_pos, rx535_off - substr $S10, rx535_tgt, $I11, 1 - ne $S10, ":", rx535_fail - add rx535_pos, 1 - # rx rxquantr541 ** 1..1 - set_addr $I547, rxquantr541_done - rx535_cur."!mark_push"(0, -1, $I547) - rxquantr541_loop: - # rx subrule $P543 subtype=capture negate= - rx535_cur."!cursor_pos"(rx535_pos) - .const 'Sub' $P543 = "149_1275511689.56967" - capture_lex $P543 - $P10 = rx535_cur.$P543() - unless $P10, rx535_fail - rx535_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx539_pos, 1 + gt $I11, rx539_eos, rx539_fail + sub $I11, rx539_pos, rx539_off + substr $S10, rx539_tgt, $I11, 1 + ne $S10, ":", rx539_fail + add rx539_pos, 1 + # rx rxquantr545 ** 1..1 + set_addr $I551, rxquantr545_done + rx539_cur."!mark_push"(0, -1, $I551) + rxquantr545_loop: + # rx subrule $P547 subtype=capture negate= + rx539_cur."!cursor_pos"(rx539_pos) + .const 'Sub' $P547 = "149_1275599996.35368" + capture_lex $P547 + $P10 = rx539_cur.$P547() + unless $P10, rx539_fail + rx539_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("n") - rx535_pos = $P10."pos"() - (rx535_rep) = rx535_cur."!mark_commit"($I547) - rxquantr541_done: + rx539_pos = $P10."pos"() + (rx539_rep) = rx539_cur."!mark_commit"($I551) + rxquantr545_done: # rx subrule "mod_ident" subtype=capture negate= - rx535_cur."!cursor_pos"(rx535_pos) - $P10 = rx535_cur."mod_ident"() - unless $P10, rx535_fail - rx535_cur."!mark_push"(0, -1, 0, $P10) + rx539_cur."!cursor_pos"(rx539_pos) + $P10 = rx539_cur."mod_ident"() + unless $P10, rx539_fail + rx539_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("mod_ident") - rx535_pos = $P10."pos"() + rx539_pos = $P10."pos"() # rxanchor rwb - le rx535_pos, 0, rx535_fail - sub $I10, rx535_pos, rx535_off - is_cclass $I11, 8192, rx535_tgt, $I10 - if $I11, rx535_fail + le rx539_pos, 0, rx539_fail + sub $I10, rx539_pos, rx539_off + is_cclass $I11, 8192, rx539_tgt, $I10 + if $I11, rx539_fail dec $I10 - is_cclass $I11, 8192, rx535_tgt, $I10 - unless $I11, rx535_fail - goto alt540_end - alt540_1: + is_cclass $I11, 8192, rx539_tgt, $I10 + unless $I11, rx539_fail + goto alt544_end + alt544_1: .annotate 'line', 177 # rx literal ":" - add $I11, rx535_pos, 1 - gt $I11, rx535_eos, rx535_fail - sub $I11, rx535_pos, rx535_off - substr $S10, rx535_tgt, $I11, 1 - ne $S10, ":", rx535_fail - add rx535_pos, 1 + add $I11, rx539_pos, 1 + gt $I11, rx539_eos, rx539_fail + sub $I11, rx539_pos, rx539_off + substr $S10, rx539_tgt, $I11, 1 + ne $S10, ":", rx539_fail + add rx539_pos, 1 # rx subrule "mod_ident" subtype=capture negate= - rx535_cur."!cursor_pos"(rx535_pos) - $P10 = rx535_cur."mod_ident"() - unless $P10, rx535_fail - rx535_cur."!mark_push"(0, -1, 0, $P10) + rx539_cur."!cursor_pos"(rx539_pos) + $P10 = rx539_cur."mod_ident"() + unless $P10, rx539_fail + rx539_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("mod_ident") - rx535_pos = $P10."pos"() - # rx rxquantr548 ** 0..1 - set_addr $I550, rxquantr548_done - rx535_cur."!mark_push"(0, rx535_pos, $I550) - rxquantr548_loop: + rx539_pos = $P10."pos"() + # rx rxquantr552 ** 0..1 + set_addr $I554, rxquantr552_done + rx539_cur."!mark_push"(0, rx539_pos, $I554) + rxquantr552_loop: # rx literal "(" - add $I11, rx535_pos, 1 - gt $I11, rx535_eos, rx535_fail - sub $I11, rx535_pos, rx535_off - substr $S10, rx535_tgt, $I11, 1 - ne $S10, "(", rx535_fail - add rx535_pos, 1 + add $I11, rx539_pos, 1 + gt $I11, rx539_eos, rx539_fail + sub $I11, rx539_pos, rx539_off + substr $S10, rx539_tgt, $I11, 1 + ne $S10, "(", rx539_fail + add rx539_pos, 1 # rx subcapture "n" - set_addr $I10, rxcap_549_fail - rx535_cur."!mark_push"(0, rx535_pos, $I10) + set_addr $I10, rxcap_553_fail + rx539_cur."!mark_push"(0, rx539_pos, $I10) # rx charclass_q d r 1..-1 - sub $I10, rx535_pos, rx535_off - find_not_cclass $I11, 8, rx535_tgt, $I10, rx535_eos + sub $I10, rx539_pos, rx539_off + find_not_cclass $I11, 8, rx539_tgt, $I10, rx539_eos add $I12, $I10, 1 - lt $I11, $I12, rx535_fail - add rx535_pos, rx535_off, $I11 - set_addr $I10, rxcap_549_fail - ($I12, $I11) = rx535_cur."!mark_peek"($I10) - rx535_cur."!cursor_pos"($I11) - ($P10) = rx535_cur."!cursor_start"() - $P10."!cursor_pass"(rx535_pos, "") - rx535_cur."!mark_push"(0, -1, 0, $P10) + lt $I11, $I12, rx539_fail + add rx539_pos, rx539_off, $I11 + set_addr $I10, rxcap_553_fail + ($I12, $I11) = rx539_cur."!mark_peek"($I10) + rx539_cur."!cursor_pos"($I11) + ($P10) = rx539_cur."!cursor_start"() + $P10."!cursor_pass"(rx539_pos, "") + rx539_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("n") - goto rxcap_549_done - rxcap_549_fail: - goto rx535_fail - rxcap_549_done: + goto rxcap_553_done + rxcap_553_fail: + goto rx539_fail + rxcap_553_done: # rx literal ")" - add $I11, rx535_pos, 1 - gt $I11, rx535_eos, rx535_fail - sub $I11, rx535_pos, rx535_off - substr $S10, rx535_tgt, $I11, 1 - ne $S10, ")", rx535_fail - add rx535_pos, 1 - (rx535_rep) = rx535_cur."!mark_commit"($I550) - rxquantr548_done: - alt540_end: + add $I11, rx539_pos, 1 + gt $I11, rx539_eos, rx539_fail + sub $I11, rx539_pos, rx539_off + substr $S10, rx539_tgt, $I11, 1 + ne $S10, ")", rx539_fail + add rx539_pos, 1 + (rx539_rep) = rx539_cur."!mark_commit"($I554) + rxquantr552_done: + alt544_end: .annotate 'line', 174 # rx pass - rx535_cur."!cursor_pass"(rx535_pos, "mod_internal") - rx535_cur."!cursor_debug"("PASS ", "mod_internal", " at pos=", rx535_pos) - .return (rx535_cur) - rx535_fail: -.annotate 'line', 3 - (rx535_rep, rx535_pos, $I10, $P10) = rx535_cur."!mark_fail"(0) - lt rx535_pos, -1, rx535_done - eq rx535_pos, -1, rx535_fail + rx539_cur."!cursor_pass"(rx539_pos, "mod_internal") + rx539_cur."!cursor_debug"("PASS ", "mod_internal", " at pos=", rx539_pos) + .return (rx539_cur) + rx539_fail: +.annotate 'line', 3 + (rx539_rep, rx539_pos, $I10, $P10) = rx539_cur."!mark_fail"(0) + lt rx539_pos, -1, rx539_done + eq rx539_pos, -1, rx539_fail jump $I10 - rx535_done: - rx535_cur."!cursor_fail"() - rx535_cur."!cursor_debug"("FAIL ", "mod_internal") - .return (rx535_cur) + rx539_done: + rx539_cur."!cursor_fail"() + rx539_cur."!cursor_debug"("FAIL ", "mod_internal") + .return (rx539_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__mod_internal" :subid("148_1275511689.56967") :method +.sub "!PREFIX__mod_internal" :subid("148_1275599996.35368") :method .annotate 'line', 3 - $P537 = self."!PREFIX__!subrule"("mod_ident", ":") - new $P538, "ResizablePMCArray" - push $P538, $P537 - push $P538, ":" - .return ($P538) + $P541 = self."!PREFIX__!subrule"("mod_ident", ":") + new $P542, "ResizablePMCArray" + push $P542, $P541 + push $P542, ":" + .return ($P542) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block542" :anon :subid("149_1275511689.56967") :method :outer("147_1275511689.56967") +.sub "_block546" :anon :subid("149_1275599996.35368") :method :outer("147_1275599996.35368") .annotate 'line', 176 - .local string rx544_tgt - .local int rx544_pos - .local int rx544_off - .local int rx544_eos - .local int rx544_rep - .local pmc rx544_cur - (rx544_cur, rx544_pos, rx544_tgt) = self."!cursor_start"() - rx544_cur."!cursor_debug"("START ", "") - .lex unicode:"$\x{a2}", rx544_cur + .local string rx548_tgt + .local int rx548_pos + .local int rx548_off + .local int rx548_eos + .local int rx548_rep + .local pmc rx548_cur + (rx548_cur, rx548_pos, rx548_tgt) = self."!cursor_start"() + rx548_cur."!cursor_debug"("START ", "") + .lex unicode:"$\x{a2}", rx548_cur .local pmc match .lex "$/", match - length rx544_eos, rx544_tgt - gt rx544_pos, rx544_eos, rx544_done - set rx544_off, 0 - lt rx544_pos, 2, rx544_start - sub rx544_off, rx544_pos, 1 - substr rx544_tgt, rx544_tgt, rx544_off - rx544_start: + length rx548_eos, rx548_tgt + gt rx548_pos, rx548_eos, rx548_done + set rx548_off, 0 + lt rx548_pos, 2, rx548_start + sub rx548_off, rx548_pos, 1 + substr rx548_tgt, rx548_tgt, rx548_off + rx548_start: $I10 = self.'from'() - ne $I10, -1, rxscan545_done - goto rxscan545_scan - rxscan545_loop: - ($P10) = rx544_cur."from"() + ne $I10, -1, rxscan549_done + goto rxscan549_scan + rxscan549_loop: + ($P10) = rx548_cur."from"() inc $P10 - set rx544_pos, $P10 - ge rx544_pos, rx544_eos, rxscan545_done - rxscan545_scan: - set_addr $I10, rxscan545_loop - rx544_cur."!mark_push"(0, rx544_pos, $I10) - rxscan545_done: - alt546_0: - set_addr $I10, alt546_1 - rx544_cur."!mark_push"(0, rx544_pos, $I10) + set rx548_pos, $P10 + ge rx548_pos, rx548_eos, rxscan549_done + rxscan549_scan: + set_addr $I10, rxscan549_loop + rx548_cur."!mark_push"(0, rx548_pos, $I10) + rxscan549_done: + alt550_0: + set_addr $I10, alt550_1 + rx548_cur."!mark_push"(0, rx548_pos, $I10) # rx literal "!" - add $I11, rx544_pos, 1 - gt $I11, rx544_eos, rx544_fail - sub $I11, rx544_pos, rx544_off - substr $S10, rx544_tgt, $I11, 1 - ne $S10, "!", rx544_fail - add rx544_pos, 1 - goto alt546_end - alt546_1: + add $I11, rx548_pos, 1 + gt $I11, rx548_eos, rx548_fail + sub $I11, rx548_pos, rx548_off + substr $S10, rx548_tgt, $I11, 1 + ne $S10, "!", rx548_fail + add rx548_pos, 1 + goto alt550_end + alt550_1: # rx charclass_q d r 1..-1 - sub $I10, rx544_pos, rx544_off - find_not_cclass $I11, 8, rx544_tgt, $I10, rx544_eos + sub $I10, rx548_pos, rx548_off + find_not_cclass $I11, 8, rx548_tgt, $I10, rx548_eos add $I12, $I10, 1 - lt $I11, $I12, rx544_fail - add rx544_pos, rx544_off, $I11 - alt546_end: + lt $I11, $I12, rx548_fail + add rx548_pos, rx548_off, $I11 + alt550_end: # rx pass - rx544_cur."!cursor_pass"(rx544_pos, "") - rx544_cur."!cursor_debug"("PASS ", "", " at pos=", rx544_pos) - .return (rx544_cur) - rx544_fail: - (rx544_rep, rx544_pos, $I10, $P10) = rx544_cur."!mark_fail"(0) - lt rx544_pos, -1, rx544_done - eq rx544_pos, -1, rx544_fail + rx548_cur."!cursor_pass"(rx548_pos, "") + rx548_cur."!cursor_debug"("PASS ", "", " at pos=", rx548_pos) + .return (rx548_cur) + rx548_fail: + (rx548_rep, rx548_pos, $I10, $P10) = rx548_cur."!mark_fail"(0) + lt rx548_pos, -1, rx548_done + eq rx548_pos, -1, rx548_fail jump $I10 - rx544_done: - rx544_cur."!cursor_fail"() - rx544_cur."!cursor_debug"("FAIL ", "") - .return (rx544_cur) + rx548_done: + rx548_cur."!cursor_fail"() + rx548_cur."!cursor_debug"("FAIL ", "") + .return (rx548_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "mod_ident" :subid("150_1275511689.56967") :method +.sub "mod_ident" :subid("150_1275599996.35368") :method .annotate 'line', 181 - $P552 = self."!protoregex"("mod_ident") - .return ($P552) + $P556 = self."!protoregex"("mod_ident") + .return ($P556) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__mod_ident" :subid("151_1275511689.56967") :method +.sub "!PREFIX__mod_ident" :subid("151_1275599996.35368") :method .annotate 'line', 181 - $P554 = self."!PREFIX__!protoregex"("mod_ident") - .return ($P554) + $P558 = self."!PREFIX__!protoregex"("mod_ident") + .return ($P558) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "mod_ident:sym" :subid("152_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "mod_ident:sym" :subid("152_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx556_tgt - .local int rx556_pos - .local int rx556_off - .local int rx556_eos - .local int rx556_rep - .local pmc rx556_cur - (rx556_cur, rx556_pos, rx556_tgt) = self."!cursor_start"() - rx556_cur."!cursor_debug"("START ", "mod_ident:sym") - .lex unicode:"$\x{a2}", rx556_cur + .local string rx560_tgt + .local int rx560_pos + .local int rx560_off + .local int rx560_eos + .local int rx560_rep + .local pmc rx560_cur + (rx560_cur, rx560_pos, rx560_tgt) = self."!cursor_start"() + rx560_cur."!cursor_debug"("START ", "mod_ident:sym") + .lex unicode:"$\x{a2}", rx560_cur .local pmc match .lex "$/", match - length rx556_eos, rx556_tgt - gt rx556_pos, rx556_eos, rx556_done - set rx556_off, 0 - lt rx556_pos, 2, rx556_start - sub rx556_off, rx556_pos, 1 - substr rx556_tgt, rx556_tgt, rx556_off - rx556_start: + length rx560_eos, rx560_tgt + gt rx560_pos, rx560_eos, rx560_done + set rx560_off, 0 + lt rx560_pos, 2, rx560_start + sub rx560_off, rx560_pos, 1 + substr rx560_tgt, rx560_tgt, rx560_off + rx560_start: $I10 = self.'from'() - ne $I10, -1, rxscan559_done - goto rxscan559_scan - rxscan559_loop: - ($P10) = rx556_cur."from"() + ne $I10, -1, rxscan563_done + goto rxscan563_scan + rxscan563_loop: + ($P10) = rx560_cur."from"() inc $P10 - set rx556_pos, $P10 - ge rx556_pos, rx556_eos, rxscan559_done - rxscan559_scan: - set_addr $I10, rxscan559_loop - rx556_cur."!mark_push"(0, rx556_pos, $I10) - rxscan559_done: + set rx560_pos, $P10 + ge rx560_pos, rx560_eos, rxscan563_done + rxscan563_scan: + set_addr $I10, rxscan563_loop + rx560_cur."!mark_push"(0, rx560_pos, $I10) + rxscan563_done: .annotate 'line', 182 # rx subcapture "sym" - set_addr $I10, rxcap_560_fail - rx556_cur."!mark_push"(0, rx556_pos, $I10) + set_addr $I10, rxcap_564_fail + rx560_cur."!mark_push"(0, rx560_pos, $I10) # rx literal "i" - add $I11, rx556_pos, 1 - gt $I11, rx556_eos, rx556_fail - sub $I11, rx556_pos, rx556_off - substr $S10, rx556_tgt, $I11, 1 - ne $S10, "i", rx556_fail - add rx556_pos, 1 - set_addr $I10, rxcap_560_fail - ($I12, $I11) = rx556_cur."!mark_peek"($I10) - rx556_cur."!cursor_pos"($I11) - ($P10) = rx556_cur."!cursor_start"() - $P10."!cursor_pass"(rx556_pos, "") - rx556_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx560_pos, 1 + gt $I11, rx560_eos, rx560_fail + sub $I11, rx560_pos, rx560_off + substr $S10, rx560_tgt, $I11, 1 + ne $S10, "i", rx560_fail + add rx560_pos, 1 + set_addr $I10, rxcap_564_fail + ($I12, $I11) = rx560_cur."!mark_peek"($I10) + rx560_cur."!cursor_pos"($I11) + ($P10) = rx560_cur."!cursor_start"() + $P10."!cursor_pass"(rx560_pos, "") + rx560_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_560_done - rxcap_560_fail: - goto rx556_fail - rxcap_560_done: - # rx rxquantr561 ** 0..1 - set_addr $I562, rxquantr561_done - rx556_cur."!mark_push"(0, rx556_pos, $I562) - rxquantr561_loop: + goto rxcap_564_done + rxcap_564_fail: + goto rx560_fail + rxcap_564_done: + # rx rxquantr565 ** 0..1 + set_addr $I566, rxquantr565_done + rx560_cur."!mark_push"(0, rx560_pos, $I566) + rxquantr565_loop: # rx literal "gnorecase" - add $I11, rx556_pos, 9 - gt $I11, rx556_eos, rx556_fail - sub $I11, rx556_pos, rx556_off - substr $S10, rx556_tgt, $I11, 9 - ne $S10, "gnorecase", rx556_fail - add rx556_pos, 9 - (rx556_rep) = rx556_cur."!mark_commit"($I562) - rxquantr561_done: + add $I11, rx560_pos, 9 + gt $I11, rx560_eos, rx560_fail + sub $I11, rx560_pos, rx560_off + substr $S10, rx560_tgt, $I11, 9 + ne $S10, "gnorecase", rx560_fail + add rx560_pos, 9 + (rx560_rep) = rx560_cur."!mark_commit"($I566) + rxquantr565_done: # rx pass - rx556_cur."!cursor_pass"(rx556_pos, "mod_ident:sym") - rx556_cur."!cursor_debug"("PASS ", "mod_ident:sym", " at pos=", rx556_pos) - .return (rx556_cur) - rx556_fail: -.annotate 'line', 3 - (rx556_rep, rx556_pos, $I10, $P10) = rx556_cur."!mark_fail"(0) - lt rx556_pos, -1, rx556_done - eq rx556_pos, -1, rx556_fail + rx560_cur."!cursor_pass"(rx560_pos, "mod_ident:sym") + rx560_cur."!cursor_debug"("PASS ", "mod_ident:sym", " at pos=", rx560_pos) + .return (rx560_cur) + rx560_fail: +.annotate 'line', 3 + (rx560_rep, rx560_pos, $I10, $P10) = rx560_cur."!mark_fail"(0) + lt rx560_pos, -1, rx560_done + eq rx560_pos, -1, rx560_fail jump $I10 - rx556_done: - rx556_cur."!cursor_fail"() - rx556_cur."!cursor_debug"("FAIL ", "mod_ident:sym") - .return (rx556_cur) + rx560_done: + rx560_cur."!cursor_fail"() + rx560_cur."!cursor_debug"("FAIL ", "mod_ident:sym") + .return (rx560_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__mod_ident:sym" :subid("153_1275511689.56967") :method +.sub "!PREFIX__mod_ident:sym" :subid("153_1275599996.35368") :method .annotate 'line', 3 - new $P558, "ResizablePMCArray" - push $P558, "i" - .return ($P558) + new $P562, "ResizablePMCArray" + push $P562, "i" + .return ($P562) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "mod_ident:sym" :subid("154_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "mod_ident:sym" :subid("154_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx564_tgt - .local int rx564_pos - .local int rx564_off - .local int rx564_eos - .local int rx564_rep - .local pmc rx564_cur - (rx564_cur, rx564_pos, rx564_tgt) = self."!cursor_start"() - rx564_cur."!cursor_debug"("START ", "mod_ident:sym") - .lex unicode:"$\x{a2}", rx564_cur + .local string rx568_tgt + .local int rx568_pos + .local int rx568_off + .local int rx568_eos + .local int rx568_rep + .local pmc rx568_cur + (rx568_cur, rx568_pos, rx568_tgt) = self."!cursor_start"() + rx568_cur."!cursor_debug"("START ", "mod_ident:sym") + .lex unicode:"$\x{a2}", rx568_cur .local pmc match .lex "$/", match - length rx564_eos, rx564_tgt - gt rx564_pos, rx564_eos, rx564_done - set rx564_off, 0 - lt rx564_pos, 2, rx564_start - sub rx564_off, rx564_pos, 1 - substr rx564_tgt, rx564_tgt, rx564_off - rx564_start: + length rx568_eos, rx568_tgt + gt rx568_pos, rx568_eos, rx568_done + set rx568_off, 0 + lt rx568_pos, 2, rx568_start + sub rx568_off, rx568_pos, 1 + substr rx568_tgt, rx568_tgt, rx568_off + rx568_start: $I10 = self.'from'() - ne $I10, -1, rxscan567_done - goto rxscan567_scan - rxscan567_loop: - ($P10) = rx564_cur."from"() + ne $I10, -1, rxscan571_done + goto rxscan571_scan + rxscan571_loop: + ($P10) = rx568_cur."from"() inc $P10 - set rx564_pos, $P10 - ge rx564_pos, rx564_eos, rxscan567_done - rxscan567_scan: - set_addr $I10, rxscan567_loop - rx564_cur."!mark_push"(0, rx564_pos, $I10) - rxscan567_done: + set rx568_pos, $P10 + ge rx568_pos, rx568_eos, rxscan571_done + rxscan571_scan: + set_addr $I10, rxscan571_loop + rx568_cur."!mark_push"(0, rx568_pos, $I10) + rxscan571_done: .annotate 'line', 183 # rx subcapture "sym" - set_addr $I10, rxcap_568_fail - rx564_cur."!mark_push"(0, rx564_pos, $I10) + set_addr $I10, rxcap_572_fail + rx568_cur."!mark_push"(0, rx568_pos, $I10) # rx literal "r" - add $I11, rx564_pos, 1 - gt $I11, rx564_eos, rx564_fail - sub $I11, rx564_pos, rx564_off - substr $S10, rx564_tgt, $I11, 1 - ne $S10, "r", rx564_fail - add rx564_pos, 1 - set_addr $I10, rxcap_568_fail - ($I12, $I11) = rx564_cur."!mark_peek"($I10) - rx564_cur."!cursor_pos"($I11) - ($P10) = rx564_cur."!cursor_start"() - $P10."!cursor_pass"(rx564_pos, "") - rx564_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx568_pos, 1 + gt $I11, rx568_eos, rx568_fail + sub $I11, rx568_pos, rx568_off + substr $S10, rx568_tgt, $I11, 1 + ne $S10, "r", rx568_fail + add rx568_pos, 1 + set_addr $I10, rxcap_572_fail + ($I12, $I11) = rx568_cur."!mark_peek"($I10) + rx568_cur."!cursor_pos"($I11) + ($P10) = rx568_cur."!cursor_start"() + $P10."!cursor_pass"(rx568_pos, "") + rx568_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_568_done - rxcap_568_fail: - goto rx564_fail - rxcap_568_done: - # rx rxquantr569 ** 0..1 - set_addr $I570, rxquantr569_done - rx564_cur."!mark_push"(0, rx564_pos, $I570) - rxquantr569_loop: + goto rxcap_572_done + rxcap_572_fail: + goto rx568_fail + rxcap_572_done: + # rx rxquantr573 ** 0..1 + set_addr $I574, rxquantr573_done + rx568_cur."!mark_push"(0, rx568_pos, $I574) + rxquantr573_loop: # rx literal "atchet" - add $I11, rx564_pos, 6 - gt $I11, rx564_eos, rx564_fail - sub $I11, rx564_pos, rx564_off - substr $S10, rx564_tgt, $I11, 6 - ne $S10, "atchet", rx564_fail - add rx564_pos, 6 - (rx564_rep) = rx564_cur."!mark_commit"($I570) - rxquantr569_done: + add $I11, rx568_pos, 6 + gt $I11, rx568_eos, rx568_fail + sub $I11, rx568_pos, rx568_off + substr $S10, rx568_tgt, $I11, 6 + ne $S10, "atchet", rx568_fail + add rx568_pos, 6 + (rx568_rep) = rx568_cur."!mark_commit"($I574) + rxquantr573_done: # rx pass - rx564_cur."!cursor_pass"(rx564_pos, "mod_ident:sym") - rx564_cur."!cursor_debug"("PASS ", "mod_ident:sym", " at pos=", rx564_pos) - .return (rx564_cur) - rx564_fail: -.annotate 'line', 3 - (rx564_rep, rx564_pos, $I10, $P10) = rx564_cur."!mark_fail"(0) - lt rx564_pos, -1, rx564_done - eq rx564_pos, -1, rx564_fail + rx568_cur."!cursor_pass"(rx568_pos, "mod_ident:sym") + rx568_cur."!cursor_debug"("PASS ", "mod_ident:sym", " at pos=", rx568_pos) + .return (rx568_cur) + rx568_fail: +.annotate 'line', 3 + (rx568_rep, rx568_pos, $I10, $P10) = rx568_cur."!mark_fail"(0) + lt rx568_pos, -1, rx568_done + eq rx568_pos, -1, rx568_fail jump $I10 - rx564_done: - rx564_cur."!cursor_fail"() - rx564_cur."!cursor_debug"("FAIL ", "mod_ident:sym") - .return (rx564_cur) + rx568_done: + rx568_cur."!cursor_fail"() + rx568_cur."!cursor_debug"("FAIL ", "mod_ident:sym") + .return (rx568_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__mod_ident:sym" :subid("155_1275511689.56967") :method +.sub "!PREFIX__mod_ident:sym" :subid("155_1275599996.35368") :method .annotate 'line', 3 - new $P566, "ResizablePMCArray" - push $P566, "r" - .return ($P566) + new $P570, "ResizablePMCArray" + push $P570, "r" + .return ($P570) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "mod_ident:sym" :subid("156_1275511689.56967") :method :outer("11_1275511689.56967") +.sub "mod_ident:sym" :subid("156_1275599996.35368") :method :outer("11_1275599996.35368") .annotate 'line', 3 - .local string rx572_tgt - .local int rx572_pos - .local int rx572_off - .local int rx572_eos - .local int rx572_rep - .local pmc rx572_cur - (rx572_cur, rx572_pos, rx572_tgt) = self."!cursor_start"() - rx572_cur."!cursor_debug"("START ", "mod_ident:sym") - .lex unicode:"$\x{a2}", rx572_cur + .local string rx576_tgt + .local int rx576_pos + .local int rx576_off + .local int rx576_eos + .local int rx576_rep + .local pmc rx576_cur + (rx576_cur, rx576_pos, rx576_tgt) = self."!cursor_start"() + rx576_cur."!cursor_debug"("START ", "mod_ident:sym") + .lex unicode:"$\x{a2}", rx576_cur .local pmc match .lex "$/", match - length rx572_eos, rx572_tgt - gt rx572_pos, rx572_eos, rx572_done - set rx572_off, 0 - lt rx572_pos, 2, rx572_start - sub rx572_off, rx572_pos, 1 - substr rx572_tgt, rx572_tgt, rx572_off - rx572_start: + length rx576_eos, rx576_tgt + gt rx576_pos, rx576_eos, rx576_done + set rx576_off, 0 + lt rx576_pos, 2, rx576_start + sub rx576_off, rx576_pos, 1 + substr rx576_tgt, rx576_tgt, rx576_off + rx576_start: $I10 = self.'from'() - ne $I10, -1, rxscan575_done - goto rxscan575_scan - rxscan575_loop: - ($P10) = rx572_cur."from"() + ne $I10, -1, rxscan579_done + goto rxscan579_scan + rxscan579_loop: + ($P10) = rx576_cur."from"() inc $P10 - set rx572_pos, $P10 - ge rx572_pos, rx572_eos, rxscan575_done - rxscan575_scan: - set_addr $I10, rxscan575_loop - rx572_cur."!mark_push"(0, rx572_pos, $I10) - rxscan575_done: + set rx576_pos, $P10 + ge rx576_pos, rx576_eos, rxscan579_done + rxscan579_scan: + set_addr $I10, rxscan579_loop + rx576_cur."!mark_push"(0, rx576_pos, $I10) + rxscan579_done: .annotate 'line', 184 # rx subcapture "sym" - set_addr $I10, rxcap_576_fail - rx572_cur."!mark_push"(0, rx572_pos, $I10) + set_addr $I10, rxcap_580_fail + rx576_cur."!mark_push"(0, rx576_pos, $I10) # rx literal "s" - add $I11, rx572_pos, 1 - gt $I11, rx572_eos, rx572_fail - sub $I11, rx572_pos, rx572_off - substr $S10, rx572_tgt, $I11, 1 - ne $S10, "s", rx572_fail - add rx572_pos, 1 - set_addr $I10, rxcap_576_fail - ($I12, $I11) = rx572_cur."!mark_peek"($I10) - rx572_cur."!cursor_pos"($I11) - ($P10) = rx572_cur."!cursor_start"() - $P10."!cursor_pass"(rx572_pos, "") - rx572_cur."!mark_push"(0, -1, 0, $P10) + add $I11, rx576_pos, 1 + gt $I11, rx576_eos, rx576_fail + sub $I11, rx576_pos, rx576_off + substr $S10, rx576_tgt, $I11, 1 + ne $S10, "s", rx576_fail + add rx576_pos, 1 + set_addr $I10, rxcap_580_fail + ($I12, $I11) = rx576_cur."!mark_peek"($I10) + rx576_cur."!cursor_pos"($I11) + ($P10) = rx576_cur."!cursor_start"() + $P10."!cursor_pass"(rx576_pos, "") + rx576_cur."!mark_push"(0, -1, 0, $P10) $P10."!cursor_names"("sym") - goto rxcap_576_done - rxcap_576_fail: - goto rx572_fail - rxcap_576_done: - # rx rxquantr577 ** 0..1 - set_addr $I578, rxquantr577_done - rx572_cur."!mark_push"(0, rx572_pos, $I578) - rxquantr577_loop: + goto rxcap_580_done + rxcap_580_fail: + goto rx576_fail + rxcap_580_done: + # rx rxquantr581 ** 0..1 + set_addr $I582, rxquantr581_done + rx576_cur."!mark_push"(0, rx576_pos, $I582) + rxquantr581_loop: # rx literal "igspace" - add $I11, rx572_pos, 7 - gt $I11, rx572_eos, rx572_fail - sub $I11, rx572_pos, rx572_off - substr $S10, rx572_tgt, $I11, 7 - ne $S10, "igspace", rx572_fail - add rx572_pos, 7 - (rx572_rep) = rx572_cur."!mark_commit"($I578) - rxquantr577_done: + add $I11, rx576_pos, 7 + gt $I11, rx576_eos, rx576_fail + sub $I11, rx576_pos, rx576_off + substr $S10, rx576_tgt, $I11, 7 + ne $S10, "igspace", rx576_fail + add rx576_pos, 7 + (rx576_rep) = rx576_cur."!mark_commit"($I582) + rxquantr581_done: # rx pass - rx572_cur."!cursor_pass"(rx572_pos, "mod_ident:sym") - rx572_cur."!cursor_debug"("PASS ", "mod_ident:sym", " at pos=", rx572_pos) - .return (rx572_cur) - rx572_fail: -.annotate 'line', 3 - (rx572_rep, rx572_pos, $I10, $P10) = rx572_cur."!mark_fail"(0) - lt rx572_pos, -1, rx572_done - eq rx572_pos, -1, rx572_fail + rx576_cur."!cursor_pass"(rx576_pos, "mod_ident:sym") + rx576_cur."!cursor_debug"("PASS ", "mod_ident:sym", " at pos=", rx576_pos) + .return (rx576_cur) + rx576_fail: +.annotate 'line', 3 + (rx576_rep, rx576_pos, $I10, $P10) = rx576_cur."!mark_fail"(0) + lt rx576_pos, -1, rx576_done + eq rx576_pos, -1, rx576_fail jump $I10 - rx572_done: - rx572_cur."!cursor_fail"() - rx572_cur."!cursor_debug"("FAIL ", "mod_ident:sym") - .return (rx572_cur) + rx576_done: + rx576_cur."!cursor_fail"() + rx576_cur."!cursor_debug"("FAIL ", "mod_ident:sym") + .return (rx576_cur) .return () .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "!PREFIX__mod_ident:sym" :subid("157_1275511689.56967") :method +.sub "!PREFIX__mod_ident:sym" :subid("157_1275599996.35368") :method .annotate 'line', 3 - new $P574, "ResizablePMCArray" - push $P574, "s" - .return ($P574) + new $P578, "ResizablePMCArray" + push $P578, "s" + .return ($P578) .end .namespace ["Regex";"P6Regex";"Grammar"] -.sub "_block579" :load :anon :subid("158_1275511689.56967") +.sub "_block583" :load :anon :subid("158_1275599996.35368") .annotate 'line', 3 - .const 'Sub' $P581 = "11_1275511689.56967" - $P582 = $P581() - .return ($P582) + .const 'Sub' $P585 = "11_1275599996.35368" + $P586 = $P585() + .return ($P586) .end .namespace [] -.sub "_block584" :load :anon :subid("159_1275511689.56967") +.sub "_block588" :load :anon :subid("159_1275599996.35368") .annotate 'line', 1 - .const 'Sub' $P586 = "10_1275511689.56967" - $P587 = $P586() - .return ($P587) + .const 'Sub' $P590 = "10_1275599996.35368" + $P591 = $P590() + .return ($P591) .end ### .include 'gen/p6regex-actions.pir' .namespace [] -.sub "_block11" :anon :subid("10_1275511714.5903") +.sub "_block11" :anon :subid("10_1275600002.0917") .annotate 'line', 0 get_hll_global $P14, ["Regex";"P6Regex";"Actions"], "_block13" capture_lex $P14 @@ -7276,155 +7294,155 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .annotate 'line', 4 get_hll_global $P14, ["Regex";"P6Regex";"Actions"], "_block13" capture_lex $P14 - $P1573 = $P14() + $P1599 = $P14() .annotate 'line', 1 - .return ($P1573) - .const 'Sub' $P1575 = "90_1275511714.5903" - .return ($P1575) + .return ($P1599) + .const 'Sub' $P1601 = "91_1275600002.0917" + .return ($P1601) .end .namespace [] -.sub "" :load :init :subid("post91") :outer("10_1275511714.5903") +.sub "" :load :init :subid("post92") :outer("10_1275600002.0917") .annotate 'line', 0 - .const 'Sub' $P12 = "10_1275511714.5903" + .const 'Sub' $P12 = "10_1275600002.0917" .local pmc block set block, $P12 - $P1578 = get_root_global ["parrot"], "P6metaclass" - $P1578."new_class"("Regex::P6Regex::Actions", "HLL::Actions" :named("parent")) + $P1604 = get_root_global ["parrot"], "P6metaclass" + $P1604."new_class"("Regex::P6Regex::Actions", "HLL::Actions" :named("parent")) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block13" :subid("11_1275511714.5903") :outer("10_1275511714.5903") +.sub "_block13" :subid("11_1275600002.0917") :outer("10_1275600002.0917") .annotate 'line', 4 - .const 'Sub' $P1535 = "88_1275511714.5903" - capture_lex $P1535 - .const 'Sub' $P1466 = "84_1275511714.5903" - capture_lex $P1466 - .const 'Sub' $P1398 = "82_1275511714.5903" - capture_lex $P1398 - .const 'Sub' $P1325 = "79_1275511714.5903" - capture_lex $P1325 - .const 'Sub' $P1311 = "78_1275511714.5903" - capture_lex $P1311 - .const 'Sub' $P1287 = "77_1275511714.5903" - capture_lex $P1287 - .const 'Sub' $P1269 = "76_1275511714.5903" - capture_lex $P1269 - .const 'Sub' $P1255 = "75_1275511714.5903" - capture_lex $P1255 - .const 'Sub' $P1242 = "74_1275511714.5903" - capture_lex $P1242 - .const 'Sub' $P1211 = "73_1275511714.5903" - capture_lex $P1211 - .const 'Sub' $P1180 = "72_1275511714.5903" - capture_lex $P1180 - .const 'Sub' $P1164 = "71_1275511714.5903" - capture_lex $P1164 - .const 'Sub' $P1148 = "70_1275511714.5903" - capture_lex $P1148 - .const 'Sub' $P1132 = "69_1275511714.5903" - capture_lex $P1132 - .const 'Sub' $P1116 = "68_1275511714.5903" - capture_lex $P1116 - .const 'Sub' $P1100 = "67_1275511714.5903" - capture_lex $P1100 - .const 'Sub' $P1084 = "66_1275511714.5903" - capture_lex $P1084 - .const 'Sub' $P1068 = "65_1275511714.5903" - capture_lex $P1068 - .const 'Sub' $P1044 = "64_1275511714.5903" - capture_lex $P1044 - .const 'Sub' $P1029 = "63_1275511714.5903" - capture_lex $P1029 - .const 'Sub' $P973 = "62_1275511714.5903" - capture_lex $P973 - .const 'Sub' $P952 = "61_1275511714.5903" - capture_lex $P952 - .const 'Sub' $P930 = "60_1275511714.5903" - capture_lex $P930 - .const 'Sub' $P920 = "59_1275511714.5903" - capture_lex $P920 - .const 'Sub' $P910 = "58_1275511714.5903" - capture_lex $P910 - .const 'Sub' $P900 = "57_1275511714.5903" - capture_lex $P900 - .const 'Sub' $P888 = "56_1275511714.5903" - capture_lex $P888 - .const 'Sub' $P876 = "55_1275511714.5903" - capture_lex $P876 - .const 'Sub' $P864 = "54_1275511714.5903" - capture_lex $P864 - .const 'Sub' $P852 = "53_1275511714.5903" - capture_lex $P852 - .const 'Sub' $P840 = "52_1275511714.5903" - capture_lex $P840 - .const 'Sub' $P828 = "51_1275511714.5903" - capture_lex $P828 - .const 'Sub' $P816 = "50_1275511714.5903" - capture_lex $P816 - .const 'Sub' $P804 = "49_1275511714.5903" - capture_lex $P804 - .const 'Sub' $P781 = "48_1275511714.5903" - capture_lex $P781 - .const 'Sub' $P758 = "47_1275511714.5903" - capture_lex $P758 - .const 'Sub' $P740 = "46_1275511714.5903" - capture_lex $P740 - .const 'Sub' $P730 = "45_1275511714.5903" - capture_lex $P730 - .const 'Sub' $P712 = "44_1275511714.5903" - capture_lex $P712 - .const 'Sub' $P665 = "43_1275511714.5903" + .const 'Sub' $P1561 = "89_1275600002.0917" + capture_lex $P1561 + .const 'Sub' $P1492 = "85_1275600002.0917" + capture_lex $P1492 + .const 'Sub' $P1424 = "83_1275600002.0917" + capture_lex $P1424 + .const 'Sub' $P1351 = "80_1275600002.0917" + capture_lex $P1351 + .const 'Sub' $P1337 = "79_1275600002.0917" + capture_lex $P1337 + .const 'Sub' $P1313 = "78_1275600002.0917" + capture_lex $P1313 + .const 'Sub' $P1295 = "77_1275600002.0917" + capture_lex $P1295 + .const 'Sub' $P1281 = "76_1275600002.0917" + capture_lex $P1281 + .const 'Sub' $P1268 = "75_1275600002.0917" + capture_lex $P1268 + .const 'Sub' $P1237 = "74_1275600002.0917" + capture_lex $P1237 + .const 'Sub' $P1206 = "73_1275600002.0917" + capture_lex $P1206 + .const 'Sub' $P1190 = "72_1275600002.0917" + capture_lex $P1190 + .const 'Sub' $P1174 = "71_1275600002.0917" + capture_lex $P1174 + .const 'Sub' $P1158 = "70_1275600002.0917" + capture_lex $P1158 + .const 'Sub' $P1142 = "69_1275600002.0917" + capture_lex $P1142 + .const 'Sub' $P1126 = "68_1275600002.0917" + capture_lex $P1126 + .const 'Sub' $P1110 = "67_1275600002.0917" + capture_lex $P1110 + .const 'Sub' $P1094 = "66_1275600002.0917" + capture_lex $P1094 + .const 'Sub' $P1070 = "65_1275600002.0917" + capture_lex $P1070 + .const 'Sub' $P1055 = "64_1275600002.0917" + capture_lex $P1055 + .const 'Sub' $P999 = "63_1275600002.0917" + capture_lex $P999 + .const 'Sub' $P978 = "62_1275600002.0917" + capture_lex $P978 + .const 'Sub' $P956 = "61_1275600002.0917" + capture_lex $P956 + .const 'Sub' $P946 = "60_1275600002.0917" + capture_lex $P946 + .const 'Sub' $P936 = "59_1275600002.0917" + capture_lex $P936 + .const 'Sub' $P926 = "58_1275600002.0917" + capture_lex $P926 + .const 'Sub' $P914 = "57_1275600002.0917" + capture_lex $P914 + .const 'Sub' $P902 = "56_1275600002.0917" + capture_lex $P902 + .const 'Sub' $P890 = "55_1275600002.0917" + capture_lex $P890 + .const 'Sub' $P878 = "54_1275600002.0917" + capture_lex $P878 + .const 'Sub' $P866 = "53_1275600002.0917" + capture_lex $P866 + .const 'Sub' $P854 = "52_1275600002.0917" + capture_lex $P854 + .const 'Sub' $P842 = "51_1275600002.0917" + capture_lex $P842 + .const 'Sub' $P830 = "50_1275600002.0917" + capture_lex $P830 + .const 'Sub' $P807 = "49_1275600002.0917" + capture_lex $P807 + .const 'Sub' $P784 = "48_1275600002.0917" + capture_lex $P784 + .const 'Sub' $P766 = "47_1275600002.0917" + capture_lex $P766 + .const 'Sub' $P756 = "46_1275600002.0917" + capture_lex $P756 + .const 'Sub' $P738 = "45_1275600002.0917" + capture_lex $P738 + .const 'Sub' $P665 = "43_1275600002.0917" capture_lex $P665 - .const 'Sub' $P648 = "42_1275511714.5903" + .const 'Sub' $P648 = "42_1275600002.0917" capture_lex $P648 - .const 'Sub' $P633 = "41_1275511714.5903" + .const 'Sub' $P633 = "41_1275600002.0917" capture_lex $P633 - .const 'Sub' $P618 = "40_1275511714.5903" + .const 'Sub' $P618 = "40_1275600002.0917" capture_lex $P618 - .const 'Sub' $P592 = "39_1275511714.5903" + .const 'Sub' $P592 = "39_1275600002.0917" capture_lex $P592 - .const 'Sub' $P541 = "37_1275511714.5903" + .const 'Sub' $P541 = "37_1275600002.0917" capture_lex $P541 - .const 'Sub' $P473 = "35_1275511714.5903" + .const 'Sub' $P473 = "35_1275600002.0917" capture_lex $P473 - .const 'Sub' $P418 = "32_1275511714.5903" + .const 'Sub' $P418 = "32_1275600002.0917" capture_lex $P418 - .const 'Sub' $P403 = "31_1275511714.5903" + .const 'Sub' $P403 = "31_1275600002.0917" capture_lex $P403 - .const 'Sub' $P377 = "29_1275511714.5903" + .const 'Sub' $P377 = "29_1275600002.0917" capture_lex $P377 - .const 'Sub' $P360 = "28_1275511714.5903" + .const 'Sub' $P360 = "28_1275600002.0917" capture_lex $P360 - .const 'Sub' $P338 = "27_1275511714.5903" + .const 'Sub' $P338 = "27_1275600002.0917" capture_lex $P338 - .const 'Sub' $P305 = "26_1275511714.5903" + .const 'Sub' $P305 = "26_1275600002.0917" capture_lex $P305 - .const 'Sub' $P50 = "13_1275511714.5903" + .const 'Sub' $P50 = "13_1275600002.0917" capture_lex $P50 - .const 'Sub' $P16 = "12_1275511714.5903" + .const 'Sub' $P16 = "12_1275600002.0917" capture_lex $P16 get_global $P15, "@MODIFIERS" - unless_null $P15, vivify_93 + unless_null $P15, vivify_94 $P15 = root_new ['parrot';'ResizablePMCArray'] set_global "@MODIFIERS", $P15 - vivify_93: -.annotate 'line', 479 - .const 'Sub' $P16 = "12_1275511714.5903" + vivify_94: +.annotate 'line', 494 + .const 'Sub' $P16 = "12_1275600002.0917" newclosure $P49, $P16 .lex "buildsub", $P49 -.annotate 'line', 496 - .const 'Sub' $P50 = "13_1275511714.5903" +.annotate 'line', 511 + .const 'Sub' $P50 = "13_1275600002.0917" newclosure $P304, $P50 .lex "capnames", $P304 -.annotate 'line', 562 - .const 'Sub' $P305 = "26_1275511714.5903" +.annotate 'line', 577 + .const 'Sub' $P305 = "26_1275600002.0917" newclosure $P337, $P305 .lex "backmod", $P337 -.annotate 'line', 569 - .const 'Sub' $P338 = "27_1275511714.5903" +.annotate 'line', 584 + .const 'Sub' $P338 = "27_1275600002.0917" newclosure $P358, $P338 .lex "subrule_alias", $P358 .annotate 'line', 4 @@ -7435,102 +7453,102 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes $P0."ctxsave"() ctxsave_done: get_global $P359, "@MODIFIERS" -.annotate 'line', 472 - find_lex $P1564, "buildsub" - find_lex $P1565, "capnames" - find_lex $P1566, "backmod" - find_lex $P1567, "subrule_alias" +.annotate 'line', 487 + find_lex $P1590, "buildsub" + find_lex $P1591, "capnames" + find_lex $P1592, "backmod" + find_lex $P1593, "subrule_alias" .annotate 'line', 4 - .return ($P1567) - .const 'Sub' $P1569 = "89_1275511714.5903" - .return ($P1569) + .return ($P1593) + .const 'Sub' $P1595 = "90_1275600002.0917" + .return ($P1595) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "" :load :init :subid("post92") :outer("11_1275511714.5903") +.sub "" :load :init :subid("post93") :outer("11_1275600002.0917") .annotate 'line', 4 get_hll_global $P14, ["Regex";"P6Regex";"Actions"], "_block13" .local pmc block set block, $P14 .annotate 'line', 7 - $P1572 = new ['ResizablePMCArray'] + $P1598 = new ['ResizablePMCArray'] $P0 = new ['Hash'] - push $P1572, $P0 + push $P1598, $P0 - set_global "@MODIFIERS", $P1572 + set_global "@MODIFIERS", $P1598 .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "buildsub" :subid("12_1275511714.5903") :outer("11_1275511714.5903") +.sub "buildsub" :subid("12_1275600002.0917") :outer("11_1275600002.0917") .param pmc param_19 .param pmc param_20 :optional .param int has_param_20 :opt_flag -.annotate 'line', 479 +.annotate 'line', 494 new $P18, 'ExceptionHandler' set_addr $P18, control_17 $P18."handle_types"(57) push_eh $P18 .lex "$rpast", param_19 - if has_param_20, optparam_94 + if has_param_20, optparam_95 get_hll_global $P21, ["PAST"], "Block" $P22 = $P21."new"() set param_20, $P22 - optparam_94: + optparam_95: .lex "$block", param_20 -.annotate 'line', 480 +.annotate 'line', 495 $P23 = root_new ['parrot';'Hash'] .lex "%capnames", $P23 find_lex $P24, "$rpast" $P25 = "capnames"($P24, 0) store_lex "%capnames", $P25 -.annotate 'line', 481 +.annotate 'line', 496 new $P26, "Integer" assign $P26, 0 find_lex $P27, "%capnames" - unless_null $P27, vivify_95 + unless_null $P27, vivify_96 $P27 = root_new ['parrot';'Hash'] store_lex "%capnames", $P27 - vivify_95: + vivify_96: set $P27[""], $P26 -.annotate 'line', 482 +.annotate 'line', 497 get_hll_global $P28, ["PAST"], "Regex" -.annotate 'line', 483 +.annotate 'line', 498 get_hll_global $P29, ["PAST"], "Regex" $P30 = $P29."new"("scan" :named("pasttype")) find_lex $P31, "$rpast" -.annotate 'line', 485 +.annotate 'line', 500 get_hll_global $P32, ["PAST"], "Regex" $P33 = $P32."new"("pass" :named("pasttype")) find_lex $P34, "%capnames" $P35 = $P28."new"($P30, $P31, $P33, "concat" :named("pasttype"), $P34 :named("capnames")) -.annotate 'line', 482 +.annotate 'line', 497 store_lex "$rpast", $P35 -.annotate 'line', 489 +.annotate 'line', 504 find_lex $P37, "$block" $P38 = $P37."symbol"(unicode:"$\x{a2}") if $P38, unless_36_end find_lex $P39, "$block" $P39."symbol"(unicode:"$\x{a2}", "lexical" :named("scope")) unless_36_end: -.annotate 'line', 490 +.annotate 'line', 505 find_lex $P41, "$block" $P42 = $P41."symbol"("$/") if $P42, unless_40_end find_lex $P43, "$block" $P43."symbol"("$/", "lexical" :named("scope")) unless_40_end: -.annotate 'line', 491 +.annotate 'line', 506 find_lex $P44, "$block" find_lex $P45, "$rpast" $P44."push"($P45) -.annotate 'line', 492 +.annotate 'line', 507 find_lex $P46, "$block" $P46."blocktype"("method") find_lex $P47, "$block" -.annotate 'line', 479 +.annotate 'line', 494 .return ($P47) control_17: .local pmc exception @@ -7541,19 +7559,19 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "capnames" :subid("13_1275511714.5903") :outer("11_1275511714.5903") +.sub "capnames" :subid("13_1275600002.0917") :outer("11_1275600002.0917") .param pmc param_53 .param pmc param_54 -.annotate 'line', 496 - .const 'Sub' $P279 = "24_1275511714.5903" +.annotate 'line', 511 + .const 'Sub' $P279 = "24_1275600002.0917" capture_lex $P279 - .const 'Sub' $P216 = "21_1275511714.5903" + .const 'Sub' $P216 = "21_1275600002.0917" capture_lex $P216 - .const 'Sub' $P174 = "19_1275511714.5903" + .const 'Sub' $P174 = "19_1275600002.0917" capture_lex $P174 - .const 'Sub' $P132 = "17_1275511714.5903" + .const 'Sub' $P132 = "17_1275600002.0917" capture_lex $P132 - .const 'Sub' $P65 = "14_1275511714.5903" + .const 'Sub' $P65 = "14_1275600002.0917" capture_lex $P65 new $P52, 'ExceptionHandler' set_addr $P52, control_51 @@ -7561,29 +7579,29 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes push_eh $P52 .lex "$ast", param_53 .lex "$count", param_54 -.annotate 'line', 497 +.annotate 'line', 512 $P55 = root_new ['parrot';'Hash'] .lex "%capnames", $P55 -.annotate 'line', 498 +.annotate 'line', 513 new $P56, "Undef" .lex "$pasttype", $P56 -.annotate 'line', 496 +.annotate 'line', 511 find_lex $P57, "%capnames" -.annotate 'line', 498 +.annotate 'line', 513 find_lex $P58, "$ast" $P59 = $P58."pasttype"() store_lex "$pasttype", $P59 -.annotate 'line', 499 +.annotate 'line', 514 find_lex $P61, "$pasttype" set $S62, $P61 iseq $I63, $S62, "alt" if $I63, if_60 -.annotate 'line', 512 +.annotate 'line', 527 find_lex $P123, "$pasttype" set $S124, $P123 iseq $I125, $S124, "concat" if $I125, if_122 -.annotate 'line', 521 +.annotate 'line', 536 find_lex $P167, "$pasttype" set $S168, $P167 iseq $I169, $S168, "subrule" @@ -7599,41 +7617,41 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes set $P165, $I172 if_166_end: if $P165, if_164 -.annotate 'line', 534 +.annotate 'line', 549 find_lex $P212, "$pasttype" set $S213, $P212 iseq $I214, $S213, "subcapture" if $I214, if_211 -.annotate 'line', 551 +.annotate 'line', 566 find_lex $P275, "$pasttype" set $S276, $P275 iseq $I277, $S276, "quant" unless $I277, if_274_end - .const 'Sub' $P279 = "24_1275511714.5903" + .const 'Sub' $P279 = "24_1275600002.0917" capture_lex $P279 $P279() if_274_end: goto if_211_end if_211: -.annotate 'line', 534 - .const 'Sub' $P216 = "21_1275511714.5903" +.annotate 'line', 549 + .const 'Sub' $P216 = "21_1275600002.0917" capture_lex $P216 $P216() if_211_end: goto if_164_end if_164: -.annotate 'line', 521 - .const 'Sub' $P174 = "19_1275511714.5903" +.annotate 'line', 536 + .const 'Sub' $P174 = "19_1275600002.0917" capture_lex $P174 $P174() if_164_end: goto if_122_end if_122: -.annotate 'line', 513 +.annotate 'line', 528 find_lex $P127, "$ast" $P128 = $P127."list"() defined $I129, $P128 - unless $I129, for_undef_116 + unless $I129, for_undef_117 iter $P126, $P128 new $P162, 'ExceptionHandler' set_addr $P162, loop161_handler @@ -7643,7 +7661,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes unless $P126, loop161_done shift $P130, $P126 loop161_redo: - .const 'Sub' $P132 = "17_1275511714.5903" + .const 'Sub' $P132 = "17_1275600002.0917" capture_lex $P132 $P132($P130) loop161_next: @@ -7656,26 +7674,26 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes eq $P163, 66, loop161_redo loop161_done: pop_eh - for_undef_116: + for_undef_117: if_122_end: -.annotate 'line', 512 +.annotate 'line', 527 goto if_60_end if_60: -.annotate 'line', 499 - .const 'Sub' $P65 = "14_1275511714.5903" +.annotate 'line', 514 + .const 'Sub' $P65 = "14_1275600002.0917" capture_lex $P65 $P65() if_60_end: -.annotate 'line', 558 +.annotate 'line', 573 find_lex $P300, "$count" find_lex $P301, "%capnames" - unless_null $P301, vivify_136 + unless_null $P301, vivify_137 $P301 = root_new ['parrot';'Hash'] store_lex "%capnames", $P301 - vivify_136: + vivify_137: set $P301[""], $P300 find_lex $P302, "%capnames" -.annotate 'line', 496 +.annotate 'line', 511 .return ($P302) control_51: .local pmc exception @@ -7686,28 +7704,28 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block278" :anon :subid("24_1275511714.5903") :outer("13_1275511714.5903") -.annotate 'line', 551 - .const 'Sub' $P290 = "25_1275511714.5903" +.sub "_block278" :anon :subid("24_1275600002.0917") :outer("13_1275600002.0917") +.annotate 'line', 566 + .const 'Sub' $P290 = "25_1275600002.0917" capture_lex $P290 -.annotate 'line', 552 +.annotate 'line', 567 $P280 = root_new ['parrot';'Hash'] .lex "%astcap", $P280 find_lex $P281, "$ast" - unless_null $P281, vivify_96 + unless_null $P281, vivify_97 $P281 = root_new ['parrot';'ResizablePMCArray'] - vivify_96: + vivify_97: set $P282, $P281[0] - unless_null $P282, vivify_97 + unless_null $P282, vivify_98 new $P282, "Undef" - vivify_97: + vivify_98: find_lex $P283, "$count" $P284 = "capnames"($P282, $P283) store_lex "%astcap", $P284 -.annotate 'line', 553 +.annotate 'line', 568 find_lex $P286, "%astcap" defined $I287, $P286 - unless $I287, for_undef_98 + unless $I287, for_undef_99 iter $P285, $P286 new $P296, 'ExceptionHandler' set_addr $P296, loop295_handler @@ -7717,7 +7735,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes unless $P285, loop295_done shift $P288, $P285 loop295_redo: - .const 'Sub' $P290 = "25_1275511714.5903" + .const 'Sub' $P290 = "25_1275600002.0917" capture_lex $P290 $P290($P288) loop295_next: @@ -7730,73 +7748,73 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes eq $P297, 66, loop295_redo loop295_done: pop_eh - for_undef_98: -.annotate 'line', 556 + for_undef_99: +.annotate 'line', 571 find_lex $P298, "%astcap" - unless_null $P298, vivify_100 + unless_null $P298, vivify_101 $P298 = root_new ['parrot';'Hash'] - vivify_100: + vivify_101: set $P299, $P298[""] - unless_null $P299, vivify_101 + unless_null $P299, vivify_102 new $P299, "Undef" - vivify_101: + vivify_102: store_lex "$count", $P299 -.annotate 'line', 551 +.annotate 'line', 566 .return ($P299) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block289" :anon :subid("25_1275511714.5903") :outer("24_1275511714.5903") +.sub "_block289" :anon :subid("25_1275600002.0917") :outer("24_1275600002.0917") .param pmc param_291 -.annotate 'line', 553 +.annotate 'line', 568 .lex "$_", param_291 -.annotate 'line', 554 +.annotate 'line', 569 new $P292, "Integer" assign $P292, 2 find_lex $P293, "$_" find_lex $P294, "%capnames" - unless_null $P294, vivify_99 + unless_null $P294, vivify_100 $P294 = root_new ['parrot';'Hash'] store_lex "%capnames", $P294 - vivify_99: + vivify_100: set $P294[$P293], $P292 -.annotate 'line', 553 +.annotate 'line', 568 .return ($P292) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block215" :anon :subid("21_1275511714.5903") :outer("13_1275511714.5903") -.annotate 'line', 534 - .const 'Sub' $P256 = "23_1275511714.5903" +.sub "_block215" :anon :subid("21_1275600002.0917") :outer("13_1275600002.0917") +.annotate 'line', 549 + .const 'Sub' $P256 = "23_1275600002.0917" capture_lex $P256 - .const 'Sub' $P228 = "22_1275511714.5903" + .const 'Sub' $P228 = "22_1275600002.0917" capture_lex $P228 -.annotate 'line', 535 +.annotate 'line', 550 new $P217, "Undef" .lex "$name", $P217 -.annotate 'line', 536 +.annotate 'line', 551 $P218 = root_new ['parrot';'ResizablePMCArray'] .lex "@names", $P218 -.annotate 'line', 545 +.annotate 'line', 560 $P219 = root_new ['parrot';'Hash'] .lex "%x", $P219 -.annotate 'line', 535 +.annotate 'line', 550 find_lex $P220, "$ast" $P221 = $P220."name"() store_lex "$name", $P221 -.annotate 'line', 536 +.annotate 'line', 551 $P0 = find_lex '$name' $S0 = $P0 $P222 = split '=', $S0 store_lex "@names", $P222 -.annotate 'line', 541 +.annotate 'line', 556 find_lex $P224, "@names" defined $I225, $P224 - unless $I225, for_undef_102 + unless $I225, for_undef_103 iter $P223, $P224 new $P245, 'ExceptionHandler' set_addr $P245, loop244_handler @@ -7806,7 +7824,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes unless $P223, loop244_done shift $P226, $P223 loop244_redo: - .const 'Sub' $P228 = "22_1275511714.5903" + .const 'Sub' $P228 = "22_1275600002.0917" capture_lex $P228 $P228($P226) loop244_next: @@ -7819,23 +7837,23 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes eq $P246, 66, loop244_redo loop244_done: pop_eh - for_undef_102: -.annotate 'line', 545 + for_undef_103: +.annotate 'line', 560 find_lex $P247, "$ast" - unless_null $P247, vivify_104 + unless_null $P247, vivify_105 $P247 = root_new ['parrot';'ResizablePMCArray'] - vivify_104: + vivify_105: set $P248, $P247[0] - unless_null $P248, vivify_105 + unless_null $P248, vivify_106 new $P248, "Undef" - vivify_105: + vivify_106: find_lex $P249, "$count" $P250 = "capnames"($P248, $P249) store_lex "%x", $P250 -.annotate 'line', 546 +.annotate 'line', 561 find_lex $P252, "%x" defined $I253, $P252 - unless $I253, for_undef_106 + unless $I253, for_undef_107 iter $P251, $P252 new $P270, 'ExceptionHandler' set_addr $P270, loop269_handler @@ -7845,7 +7863,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes unless $P251, loop269_done shift $P254, $P251 loop269_redo: - .const 'Sub' $P256 = "23_1275511714.5903" + .const 'Sub' $P256 = "23_1275600002.0917" capture_lex $P256 $P256($P254) loop269_next: @@ -7858,28 +7876,28 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes eq $P271, 66, loop269_redo loop269_done: pop_eh - for_undef_106: -.annotate 'line', 549 + for_undef_107: +.annotate 'line', 564 find_lex $P272, "%x" - unless_null $P272, vivify_112 + unless_null $P272, vivify_113 $P272 = root_new ['parrot';'Hash'] - vivify_112: + vivify_113: set $P273, $P272[""] - unless_null $P273, vivify_113 + unless_null $P273, vivify_114 new $P273, "Undef" - vivify_113: + vivify_114: store_lex "$count", $P273 -.annotate 'line', 534 +.annotate 'line', 549 .return ($P273) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block227" :anon :subid("22_1275511714.5903") :outer("21_1275511714.5903") +.sub "_block227" :anon :subid("22_1275600002.0917") :outer("21_1275600002.0917") .param pmc param_229 -.annotate 'line', 541 +.annotate 'line', 556 .lex "$_", param_229 -.annotate 'line', 542 +.annotate 'line', 557 find_lex $P233, "$_" set $S234, $P233 iseq $I235, $S234, "0" @@ -7899,77 +7917,77 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes add $P240, $P239, 1 store_lex "$count", $P240 if_230_end: -.annotate 'line', 543 +.annotate 'line', 558 new $P241, "Integer" assign $P241, 1 find_lex $P242, "$_" find_lex $P243, "%capnames" - unless_null $P243, vivify_103 + unless_null $P243, vivify_104 $P243 = root_new ['parrot';'Hash'] store_lex "%capnames", $P243 - vivify_103: + vivify_104: set $P243[$P242], $P241 -.annotate 'line', 541 +.annotate 'line', 556 .return ($P241) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block255" :anon :subid("23_1275511714.5903") :outer("21_1275511714.5903") +.sub "_block255" :anon :subid("23_1275600002.0917") :outer("21_1275600002.0917") .param pmc param_257 -.annotate 'line', 546 +.annotate 'line', 561 .lex "$_", param_257 -.annotate 'line', 547 +.annotate 'line', 562 find_lex $P258, "$_" find_lex $P259, "%capnames" - unless_null $P259, vivify_107 + unless_null $P259, vivify_108 $P259 = root_new ['parrot';'Hash'] - vivify_107: + vivify_108: set $P260, $P259[$P258] - unless_null $P260, vivify_108 + unless_null $P260, vivify_109 new $P260, "Undef" - vivify_108: + vivify_109: set $N261, $P260 new $P262, 'Float' set $P262, $N261 find_lex $P263, "$_" find_lex $P264, "%x" - unless_null $P264, vivify_109 + unless_null $P264, vivify_110 $P264 = root_new ['parrot';'Hash'] - vivify_109: + vivify_110: set $P265, $P264[$P263] - unless_null $P265, vivify_110 + unless_null $P265, vivify_111 new $P265, "Undef" - vivify_110: + vivify_111: add $P266, $P262, $P265 find_lex $P267, "$_" find_lex $P268, "%capnames" - unless_null $P268, vivify_111 + unless_null $P268, vivify_112 $P268 = root_new ['parrot';'Hash'] store_lex "%capnames", $P268 - vivify_111: + vivify_112: set $P268[$P267], $P266 -.annotate 'line', 546 +.annotate 'line', 561 .return ($P266) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block173" :anon :subid("19_1275511714.5903") :outer("13_1275511714.5903") -.annotate 'line', 521 - .const 'Sub' $P192 = "20_1275511714.5903" +.sub "_block173" :anon :subid("19_1275600002.0917") :outer("13_1275600002.0917") +.annotate 'line', 536 + .const 'Sub' $P192 = "20_1275600002.0917" capture_lex $P192 -.annotate 'line', 522 +.annotate 'line', 537 new $P175, "Undef" .lex "$name", $P175 -.annotate 'line', 524 +.annotate 'line', 539 $P176 = root_new ['parrot';'ResizablePMCArray'] .lex "@names", $P176 -.annotate 'line', 522 +.annotate 'line', 537 find_lex $P177, "$ast" $P178 = $P177."name"() store_lex "$name", $P178 -.annotate 'line', 523 +.annotate 'line', 538 find_lex $P180, "$name" set $S181, $P180 iseq $I182, $S181, "" @@ -7980,17 +7998,17 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes find_lex $P185, "$name" $P184."name"($P185) if_179_end: -.annotate 'line', 524 +.annotate 'line', 539 $P0 = find_lex '$name' $S0 = $P0 $P186 = split '=', $S0 store_lex "@names", $P186 -.annotate 'line', 529 +.annotate 'line', 544 find_lex $P188, "@names" defined $I189, $P188 - unless $I189, for_undef_114 + unless $I189, for_undef_115 iter $P187, $P188 new $P209, 'ExceptionHandler' set_addr $P209, loop208_handler @@ -8000,7 +8018,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes unless $P187, loop208_done shift $P190, $P187 loop208_redo: - .const 'Sub' $P192 = "20_1275511714.5903" + .const 'Sub' $P192 = "20_1275600002.0917" capture_lex $P192 $P192($P190) loop208_next: @@ -8013,18 +8031,18 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes eq $P210, 66, loop208_redo loop208_done: pop_eh - for_undef_114: -.annotate 'line', 521 + for_undef_115: +.annotate 'line', 536 .return ($P187) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block191" :anon :subid("20_1275511714.5903") :outer("19_1275511714.5903") +.sub "_block191" :anon :subid("20_1275600002.0917") :outer("19_1275600002.0917") .param pmc param_193 -.annotate 'line', 529 +.annotate 'line', 544 .lex "$_", param_193 -.annotate 'line', 530 +.annotate 'line', 545 find_lex $P197, "$_" set $S198, $P197 iseq $I199, $S198, "0" @@ -8044,28 +8062,28 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes add $P204, $P203, 1 store_lex "$count", $P204 if_194_end: -.annotate 'line', 531 +.annotate 'line', 546 new $P205, "Integer" assign $P205, 1 find_lex $P206, "$_" find_lex $P207, "%capnames" - unless_null $P207, vivify_115 + unless_null $P207, vivify_116 $P207 = root_new ['parrot';'Hash'] store_lex "%capnames", $P207 - vivify_115: + vivify_116: set $P207[$P206], $P205 -.annotate 'line', 529 +.annotate 'line', 544 .return ($P205) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block131" :anon :subid("17_1275511714.5903") :outer("13_1275511714.5903") +.sub "_block131" :anon :subid("17_1275600002.0917") :outer("13_1275600002.0917") .param pmc param_134 -.annotate 'line', 513 - .const 'Sub' $P143 = "18_1275511714.5903" +.annotate 'line', 528 + .const 'Sub' $P143 = "18_1275600002.0917" capture_lex $P143 -.annotate 'line', 514 +.annotate 'line', 529 $P133 = root_new ['parrot';'Hash'] .lex "%x", $P133 .lex "$_", param_134 @@ -8073,10 +8091,10 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes find_lex $P136, "$count" $P137 = "capnames"($P135, $P136) store_lex "%x", $P137 -.annotate 'line', 515 +.annotate 'line', 530 find_lex $P139, "%x" defined $I140, $P139 - unless $I140, for_undef_117 + unless $I140, for_undef_118 iter $P138, $P139 new $P157, 'ExceptionHandler' set_addr $P157, loop156_handler @@ -8086,7 +8104,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes unless $P138, loop156_done shift $P141, $P138 loop156_redo: - .const 'Sub' $P143 = "18_1275511714.5903" + .const 'Sub' $P143 = "18_1275600002.0917" capture_lex $P143 $P143($P141) loop156_next: @@ -8099,77 +8117,77 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes eq $P158, 66, loop156_redo loop156_done: pop_eh - for_undef_117: -.annotate 'line', 518 + for_undef_118: +.annotate 'line', 533 find_lex $P159, "%x" - unless_null $P159, vivify_123 + unless_null $P159, vivify_124 $P159 = root_new ['parrot';'Hash'] - vivify_123: + vivify_124: set $P160, $P159[""] - unless_null $P160, vivify_124 + unless_null $P160, vivify_125 new $P160, "Undef" - vivify_124: + vivify_125: store_lex "$count", $P160 -.annotate 'line', 513 +.annotate 'line', 528 .return ($P160) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block142" :anon :subid("18_1275511714.5903") :outer("17_1275511714.5903") +.sub "_block142" :anon :subid("18_1275600002.0917") :outer("17_1275600002.0917") .param pmc param_144 -.annotate 'line', 515 +.annotate 'line', 530 .lex "$_", param_144 -.annotate 'line', 516 +.annotate 'line', 531 find_lex $P145, "$_" find_lex $P146, "%capnames" - unless_null $P146, vivify_118 + unless_null $P146, vivify_119 $P146 = root_new ['parrot';'Hash'] - vivify_118: + vivify_119: set $P147, $P146[$P145] - unless_null $P147, vivify_119 + unless_null $P147, vivify_120 new $P147, "Undef" - vivify_119: + vivify_120: set $N148, $P147 new $P149, 'Float' set $P149, $N148 find_lex $P150, "$_" find_lex $P151, "%x" - unless_null $P151, vivify_120 + unless_null $P151, vivify_121 $P151 = root_new ['parrot';'Hash'] - vivify_120: + vivify_121: set $P152, $P151[$P150] - unless_null $P152, vivify_121 + unless_null $P152, vivify_122 new $P152, "Undef" - vivify_121: + vivify_122: add $P153, $P149, $P152 find_lex $P154, "$_" find_lex $P155, "%capnames" - unless_null $P155, vivify_122 + unless_null $P155, vivify_123 $P155 = root_new ['parrot';'Hash'] store_lex "%capnames", $P155 - vivify_122: + vivify_123: set $P155[$P154], $P153 -.annotate 'line', 515 +.annotate 'line', 530 .return ($P153) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block64" :anon :subid("14_1275511714.5903") :outer("13_1275511714.5903") -.annotate 'line', 499 - .const 'Sub' $P74 = "15_1275511714.5903" +.sub "_block64" :anon :subid("14_1275600002.0917") :outer("13_1275600002.0917") +.annotate 'line', 514 + .const 'Sub' $P74 = "15_1275600002.0917" capture_lex $P74 -.annotate 'line', 500 +.annotate 'line', 515 new $P66, "Undef" .lex "$max", $P66 find_lex $P67, "$count" store_lex "$max", $P67 -.annotate 'line', 501 +.annotate 'line', 516 find_lex $P69, "$ast" $P70 = $P69."list"() defined $I71, $P70 - unless $I71, for_undef_125 + unless $I71, for_undef_126 iter $P68, $P70 new $P119, 'ExceptionHandler' set_addr $P119, loop118_handler @@ -8179,7 +8197,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes unless $P68, loop118_done shift $P72, $P68 loop118_redo: - .const 'Sub' $P74 = "15_1275511714.5903" + .const 'Sub' $P74 = "15_1275600002.0917" capture_lex $P74 $P74($P72) loop118_next: @@ -8192,22 +8210,22 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes eq $P120, 66, loop118_redo loop118_done: pop_eh - for_undef_125: -.annotate 'line', 510 + for_undef_126: +.annotate 'line', 525 find_lex $P121, "$max" store_lex "$count", $P121 -.annotate 'line', 499 +.annotate 'line', 514 .return ($P121) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block73" :anon :subid("15_1275511714.5903") :outer("14_1275511714.5903") +.sub "_block73" :anon :subid("15_1275600002.0917") :outer("14_1275600002.0917") .param pmc param_76 -.annotate 'line', 501 - .const 'Sub' $P85 = "16_1275511714.5903" +.annotate 'line', 516 + .const 'Sub' $P85 = "16_1275600002.0917" capture_lex $P85 -.annotate 'line', 502 +.annotate 'line', 517 $P75 = root_new ['parrot';'Hash'] .lex "%x", $P75 .lex "$_", param_76 @@ -8215,10 +8233,10 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes find_lex $P78, "$count" $P79 = "capnames"($P77, $P78) store_lex "%x", $P79 -.annotate 'line', 503 +.annotate 'line', 518 find_lex $P81, "%x" defined $I82, $P81 - unless $I82, for_undef_126 + unless $I82, for_undef_127 iter $P80, $P81 new $P106, 'ExceptionHandler' set_addr $P106, loop105_handler @@ -8228,7 +8246,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes unless $P80, loop105_done shift $P83, $P80 loop105_redo: - .const 'Sub' $P85 = "16_1275511714.5903" + .const 'Sub' $P85 = "16_1275600002.0917" capture_lex $P85 $P85($P83) loop105_next: @@ -8241,16 +8259,16 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes eq $P107, 66, loop105_redo loop105_done: pop_eh - for_undef_126: -.annotate 'line', 508 + for_undef_127: +.annotate 'line', 523 find_lex $P110, "%x" - unless_null $P110, vivify_132 + unless_null $P110, vivify_133 $P110 = root_new ['parrot';'Hash'] - vivify_132: + vivify_133: set $P111, $P110[""] - unless_null $P111, vivify_133 + unless_null $P111, vivify_134 new $P111, "Undef" - vivify_133: + vivify_134: set $N112, $P111 find_lex $P113, "$max" set $N114, $P113 @@ -8261,36 +8279,36 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes goto if_109_end if_109: find_lex $P116, "%x" - unless_null $P116, vivify_134 + unless_null $P116, vivify_135 $P116 = root_new ['parrot';'Hash'] - vivify_134: + vivify_135: set $P117, $P116[""] - unless_null $P117, vivify_135 + unless_null $P117, vivify_136 new $P117, "Undef" - vivify_135: + vivify_136: store_lex "$max", $P117 set $P108, $P117 if_109_end: -.annotate 'line', 501 +.annotate 'line', 516 .return ($P108) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block84" :anon :subid("16_1275511714.5903") :outer("15_1275511714.5903") +.sub "_block84" :anon :subid("16_1275600002.0917") :outer("15_1275600002.0917") .param pmc param_86 -.annotate 'line', 503 +.annotate 'line', 518 .lex "$_", param_86 -.annotate 'line', 504 +.annotate 'line', 519 find_lex $P91, "$_" find_lex $P92, "%capnames" - unless_null $P92, vivify_127 + unless_null $P92, vivify_128 $P92 = root_new ['parrot';'Hash'] - vivify_127: + vivify_128: set $P93, $P92[$P91] - unless_null $P93, vivify_128 + unless_null $P93, vivify_129 new $P93, "Undef" - vivify_128: + vivify_129: set $N94, $P93 islt $I95, $N94, 2.0 if $I95, if_90 @@ -8300,13 +8318,13 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes if_90: find_lex $P96, "$_" find_lex $P97, "%x" - unless_null $P97, vivify_129 + unless_null $P97, vivify_130 $P97 = root_new ['parrot';'Hash'] - vivify_129: + vivify_130: set $P98, $P97[$P96] - unless_null $P98, vivify_130 + unless_null $P98, vivify_131 new $P98, "Undef" - vivify_130: + vivify_131: set $N99, $P98 iseq $I100, $N99, 1.0 new $P89, 'Integer' @@ -8322,36 +8340,36 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes assign $P101, 1 set $P87, $P101 if_88_end: -.annotate 'line', 505 +.annotate 'line', 520 find_lex $P103, "$_" find_lex $P104, "%capnames" - unless_null $P104, vivify_131 + unless_null $P104, vivify_132 $P104 = root_new ['parrot';'Hash'] store_lex "%capnames", $P104 - vivify_131: + vivify_132: set $P104[$P103], $P87 -.annotate 'line', 503 +.annotate 'line', 518 .return ($P87) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "backmod" :subid("26_1275511714.5903") :outer("11_1275511714.5903") +.sub "backmod" :subid("26_1275600002.0917") :outer("11_1275600002.0917") .param pmc param_308 .param pmc param_309 -.annotate 'line', 562 +.annotate 'line', 577 new $P307, 'ExceptionHandler' set_addr $P307, control_306 $P307."handle_types"(57) push_eh $P307 .lex "$ast", param_308 .lex "$backmod", param_309 -.annotate 'line', 563 +.annotate 'line', 578 find_lex $P311, "$backmod" set $S312, $P311 iseq $I313, $S312, ":" if $I313, if_310 -.annotate 'line', 564 +.annotate 'line', 579 find_lex $P318, "$backmod" set $S319, $P318 iseq $I320, $S319, ":?" @@ -8367,7 +8385,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes set $P316, $I323 unless_317_end: if $P316, if_315 -.annotate 'line', 565 +.annotate 'line', 580 find_lex $P328, "$backmod" set $S329, $P328 iseq $I330, $S329, ":!" @@ -8388,18 +8406,18 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes if_325_end: goto if_315_end if_315: -.annotate 'line', 564 +.annotate 'line', 579 find_lex $P324, "$ast" $P324."backtrack"("f") if_315_end: goto if_310_end if_310: -.annotate 'line', 563 +.annotate 'line', 578 find_lex $P314, "$ast" $P314."backtrack"("r") if_310_end: find_lex $P335, "$ast" -.annotate 'line', 562 +.annotate 'line', 577 .return ($P335) control_306: .local pmc exception @@ -8410,28 +8428,28 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "subrule_alias" :subid("27_1275511714.5903") :outer("11_1275511714.5903") +.sub "subrule_alias" :subid("27_1275600002.0917") :outer("11_1275600002.0917") .param pmc param_341 .param pmc param_342 -.annotate 'line', 569 +.annotate 'line', 584 new $P340, 'ExceptionHandler' set_addr $P340, control_339 $P340."handle_types"(57) push_eh $P340 .lex "$past", param_341 .lex "$name", param_342 -.annotate 'line', 570 +.annotate 'line', 585 find_lex $P344, "$past" $S345 = $P344."name"() isgt $I346, $S345, "" if $I346, if_343 -.annotate 'line', 571 +.annotate 'line', 586 find_lex $P353, "$past" find_lex $P354, "$name" $P353."name"($P354) goto if_343_end if_343: -.annotate 'line', 570 +.annotate 'line', 585 find_lex $P347, "$past" find_lex $P348, "$name" concat $P349, $P348, "=" @@ -8440,10 +8458,10 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes concat $P352, $P349, $S351 $P347."name"($P352) if_343_end: -.annotate 'line', 572 +.annotate 'line', 587 find_lex $P355, "$past" $P356 = $P355."subtype"("capture") -.annotate 'line', 569 +.annotate 'line', 584 .return ($P356) control_339: .local pmc exception @@ -8454,7 +8472,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "arg" :subid("28_1275511714.5903") :method :outer("11_1275511714.5903") +.sub "arg" :subid("28_1275600002.0917") :method :outer("11_1275600002.0917") .param pmc param_363 .annotate 'line', 14 new $P362, 'ExceptionHandler' @@ -8466,35 +8484,35 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .annotate 'line', 15 find_lex $P364, "$/" find_lex $P367, "$/" - unless_null $P367, vivify_137 + unless_null $P367, vivify_138 $P367 = root_new ['parrot';'Hash'] - vivify_137: + vivify_138: set $P368, $P367["quote_EXPR"] - unless_null $P368, vivify_138 + unless_null $P368, vivify_139 new $P368, "Undef" - vivify_138: + vivify_139: if $P368, if_366 find_lex $P372, "$/" - unless_null $P372, vivify_139 + unless_null $P372, vivify_140 $P372 = root_new ['parrot';'Hash'] - vivify_139: + vivify_140: set $P373, $P372["val"] - unless_null $P373, vivify_140 + unless_null $P373, vivify_141 new $P373, "Undef" - vivify_140: + vivify_141: set $N374, $P373 new $P365, 'Float' set $P365, $N374 goto if_366_end if_366: find_lex $P369, "$/" - unless_null $P369, vivify_141 + unless_null $P369, vivify_142 $P369 = root_new ['parrot';'Hash'] - vivify_141: + vivify_142: set $P370, $P369["quote_EXPR"] - unless_null $P370, vivify_142 + unless_null $P370, vivify_143 new $P370, "Undef" - vivify_142: + vivify_143: $P371 = $P370."ast"() set $P365, $P371 if_366_end: @@ -8510,10 +8528,10 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "arglist" :subid("29_1275511714.5903") :method :outer("11_1275511714.5903") +.sub "arglist" :subid("29_1275600002.0917") :method :outer("11_1275600002.0917") .param pmc param_380 .annotate 'line', 18 - .const 'Sub' $P390 = "30_1275511714.5903" + .const 'Sub' $P390 = "30_1275600002.0917" capture_lex $P390 new $P379, 'ExceptionHandler' set_addr $P379, control_378 @@ -8529,15 +8547,15 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes store_lex "$past", $P383 .annotate 'line', 20 find_lex $P385, "$/" - unless_null $P385, vivify_143 + unless_null $P385, vivify_144 $P385 = root_new ['parrot';'Hash'] - vivify_143: + vivify_144: set $P386, $P385["arg"] - unless_null $P386, vivify_144 + unless_null $P386, vivify_145 new $P386, "Undef" - vivify_144: + vivify_145: defined $I387, $P386 - unless $I387, for_undef_145 + unless $I387, for_undef_146 iter $P384, $P386 new $P397, 'ExceptionHandler' set_addr $P397, loop396_handler @@ -8547,7 +8565,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes unless $P384, loop396_done shift $P388, $P384 loop396_redo: - .const 'Sub' $P390 = "30_1275511714.5903" + .const 'Sub' $P390 = "30_1275600002.0917" capture_lex $P390 $P390($P388) loop396_next: @@ -8560,7 +8578,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes eq $P398, 66, loop396_redo loop396_done: pop_eh - for_undef_145: + for_undef_146: .annotate 'line', 21 find_lex $P399, "$/" find_lex $P400, "$past" @@ -8576,7 +8594,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block389" :anon :subid("30_1275511714.5903") :outer("29_1275511714.5903") +.sub "_block389" :anon :subid("30_1275600002.0917") :outer("29_1275600002.0917") .param pmc param_391 .annotate 'line', 20 .lex "$_", param_391 @@ -8589,7 +8607,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "TOP" :subid("31_1275511714.5903") :method :outer("11_1275511714.5903") +.sub "TOP" :subid("31_1275600002.0917") :method :outer("11_1275600002.0917") .param pmc param_406 .annotate 'line', 24 new $P405, 'ExceptionHandler' @@ -8602,13 +8620,13 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes new $P407, "Undef" .lex "$past", $P407 find_lex $P408, "$/" - unless_null $P408, vivify_146 + unless_null $P408, vivify_147 $P408 = root_new ['parrot';'Hash'] - vivify_146: + vivify_147: set $P409, $P408["nibbler"] - unless_null $P409, vivify_147 + unless_null $P409, vivify_148 new $P409, "Undef" - vivify_147: + vivify_148: $P410 = $P409."ast"() $P411 = "buildsub"($P410) store_lex "$past", $P411 @@ -8631,14 +8649,14 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "nibbler" :subid("32_1275511714.5903") :method :outer("11_1275511714.5903") +.sub "nibbler" :subid("32_1275600002.0917") :method :outer("11_1275600002.0917") .param pmc param_421 .param pmc param_422 :optional .param int has_param_422 :opt_flag .annotate 'line', 30 - .const 'Sub' $P456 = "34_1275511714.5903" + .const 'Sub' $P456 = "34_1275600002.0917" capture_lex $P456 - .const 'Sub' $P430 = "33_1275511714.5903" + .const 'Sub' $P430 = "33_1275600002.0917" capture_lex $P430 new $P420, 'ExceptionHandler' set_addr $P420, control_419 @@ -8646,10 +8664,10 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes push_eh $P420 .lex "self", self .lex "$/", param_421 - if has_param_422, optparam_148 + if has_param_422, optparam_149 new $P423, "Undef" set param_422, $P423 - optparam_148: + optparam_149: .lex "$key", param_422 .annotate 'line', 42 new $P424, "Undef" @@ -8659,7 +8677,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes set $S427, $P426 iseq $I428, $S427, "open" unless $I428, if_425_end - .const 'Sub' $P430 = "33_1275511714.5903" + .const 'Sub' $P430 = "33_1275600002.0917" capture_lex $P430 $P430() if_425_end: @@ -8669,29 +8687,29 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes find_lex $P441, "$past" .annotate 'line', 43 find_lex $P443, "$/" - unless_null $P443, vivify_151 + unless_null $P443, vivify_152 $P443 = root_new ['parrot';'Hash'] - vivify_151: + vivify_152: set $P444, $P443["termish"] - unless_null $P444, vivify_152 + unless_null $P444, vivify_153 new $P444, "Undef" - vivify_152: + vivify_153: set $N445, $P444 isgt $I446, $N445, 1.0 if $I446, if_442 .annotate 'line', 50 find_lex $P465, "$/" - unless_null $P465, vivify_153 + unless_null $P465, vivify_154 $P465 = root_new ['parrot';'Hash'] - vivify_153: + vivify_154: set $P466, $P465["termish"] - unless_null $P466, vivify_154 + unless_null $P466, vivify_155 $P466 = root_new ['parrot';'ResizablePMCArray'] - vivify_154: + vivify_155: set $P467, $P466[0] - unless_null $P467, vivify_155 + unless_null $P467, vivify_156 new $P467, "Undef" - vivify_155: + vivify_156: $P468 = $P467."ast"() store_lex "$past", $P468 .annotate 'line', 49 @@ -8704,15 +8722,15 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes store_lex "$past", $P449 .annotate 'line', 45 find_lex $P451, "$/" - unless_null $P451, vivify_156 + unless_null $P451, vivify_157 $P451 = root_new ['parrot';'Hash'] - vivify_156: + vivify_157: set $P452, $P451["termish"] - unless_null $P452, vivify_157 + unless_null $P452, vivify_158 new $P452, "Undef" - vivify_157: + vivify_158: defined $I453, $P452 - unless $I453, for_undef_158 + unless $I453, for_undef_159 iter $P450, $P452 new $P463, 'ExceptionHandler' set_addr $P463, loop462_handler @@ -8722,7 +8740,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes unless $P450, loop462_done shift $P454, $P450 loop462_redo: - .const 'Sub' $P456 = "34_1275511714.5903" + .const 'Sub' $P456 = "34_1275600002.0917" capture_lex $P456 $P456($P454) loop462_next: @@ -8735,7 +8753,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes eq $P464, 66, loop462_redo loop462_done: pop_eh - for_undef_158: + for_undef_159: if_442_end: .annotate 'line', 52 find_lex $P469, "$/" @@ -8752,7 +8770,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block429" :anon :subid("33_1275511714.5903") :outer("32_1275511714.5903") +.sub "_block429" :anon :subid("33_1275600002.0917") :outer("32_1275600002.0917") .annotate 'line', 32 $P431 = root_new ['parrot';'Hash'] .lex "%old", $P431 @@ -8761,13 +8779,13 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .lex "%new", $P432 .annotate 'line', 32 get_global $P433, "@MODIFIERS" - unless_null $P433, vivify_149 + unless_null $P433, vivify_150 $P433 = root_new ['parrot';'ResizablePMCArray'] - vivify_149: + vivify_150: set $P434, $P433[0] - unless_null $P434, vivify_150 + unless_null $P434, vivify_151 new $P434, "Undef" - vivify_150: + vivify_151: store_lex "%old", $P434 .annotate 'line', 33 @@ -8792,7 +8810,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block455" :anon :subid("34_1275511714.5903") :outer("32_1275511714.5903") +.sub "_block455" :anon :subid("34_1275600002.0917") :outer("32_1275600002.0917") .param pmc param_457 .annotate 'line', 45 .lex "$_", param_457 @@ -8807,10 +8825,10 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "termish" :subid("35_1275511714.5903") :method :outer("11_1275511714.5903") +.sub "termish" :subid("35_1275600002.0917") :method :outer("11_1275600002.0917") .param pmc param_476 .annotate 'line', 55 - .const 'Sub' $P489 = "36_1275511714.5903" + .const 'Sub' $P489 = "36_1275600002.0917" capture_lex $P489 new $P475, 'ExceptionHandler' set_addr $P475, control_474 @@ -8835,15 +8853,15 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes store_lex "$lastlit", $P482 .annotate 'line', 58 find_lex $P484, "$/" - unless_null $P484, vivify_159 + unless_null $P484, vivify_160 $P484 = root_new ['parrot';'Hash'] - vivify_159: + vivify_160: set $P485, $P484["noun"] - unless_null $P485, vivify_160 + unless_null $P485, vivify_161 new $P485, "Undef" - vivify_160: + vivify_161: defined $I486, $P485 - unless $I486, for_undef_161 + unless $I486, for_undef_162 iter $P483, $P485 new $P535, 'ExceptionHandler' set_addr $P535, loop534_handler @@ -8853,7 +8871,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes unless $P483, loop534_done shift $P487, $P483 loop534_redo: - .const 'Sub' $P489 = "36_1275511714.5903" + .const 'Sub' $P489 = "36_1275600002.0917" capture_lex $P489 $P489($P487) loop534_next: @@ -8866,7 +8884,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes eq $P536, 66, loop534_redo loop534_done: pop_eh - for_undef_161: + for_undef_162: .annotate 'line', 73 find_lex $P537, "$/" find_lex $P538, "$past" @@ -8882,7 +8900,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block488" :anon :subid("36_1275511714.5903") :outer("35_1275511714.5903") +.sub "_block488" :anon :subid("36_1275600002.0917") :outer("35_1275600002.0917") .param pmc param_491 .annotate 'line', 59 new $P490, "Undef" @@ -8916,13 +8934,13 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .annotate 'line', 62 get_hll_global $P507, ["PAST"], "Node" find_lex $P508, "$ast" - unless_null $P508, vivify_162 + unless_null $P508, vivify_163 $P508 = root_new ['parrot';'ResizablePMCArray'] - vivify_162: + vivify_163: set $P509, $P508[0] - unless_null $P509, vivify_163 + unless_null $P509, vivify_164 new $P509, "Undef" - vivify_163: + vivify_164: $P510 = $P507."ACCEPTS"($P509) isfalse $I511, $P510 new $P499, 'Integer' @@ -8945,13 +8963,13 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .annotate 'line', 68 get_hll_global $P527, ["PAST"], "Node" find_lex $P528, "$ast" - unless_null $P528, vivify_164 + unless_null $P528, vivify_165 $P528 = root_new ['parrot';'ResizablePMCArray'] - vivify_164: + vivify_165: set $P529, $P528[0] - unless_null $P529, vivify_165 + unless_null $P529, vivify_166 new $P529, "Undef" - vivify_165: + vivify_166: $P530 = $P527."ACCEPTS"($P529) isfalse $I531, $P530 new $P522, 'Integer' @@ -8975,27 +8993,27 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes if_498: .annotate 'line', 63 find_lex $P512, "$lastlit" - unless_null $P512, vivify_166 + unless_null $P512, vivify_167 $P512 = root_new ['parrot';'ResizablePMCArray'] - vivify_166: + vivify_167: set $P513, $P512[0] - unless_null $P513, vivify_167 + unless_null $P513, vivify_168 new $P513, "Undef" - vivify_167: + vivify_168: find_lex $P514, "$ast" - unless_null $P514, vivify_168 + unless_null $P514, vivify_169 $P514 = root_new ['parrot';'ResizablePMCArray'] - vivify_168: + vivify_169: set $P515, $P514[0] - unless_null $P515, vivify_169 + unless_null $P515, vivify_170 new $P515, "Undef" - vivify_169: + vivify_170: concat $P516, $P513, $P515 find_lex $P517, "$lastlit" - unless_null $P517, vivify_170 + unless_null $P517, vivify_171 $P517 = root_new ['parrot';'ResizablePMCArray'] store_lex "$lastlit", $P517 - vivify_170: + vivify_171: set $P517[0], $P516 .annotate 'line', 62 set $P497, $P516 @@ -9009,10 +9027,10 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "quantified_atom" :subid("37_1275511714.5903") :method :outer("11_1275511714.5903") +.sub "quantified_atom" :subid("37_1275600002.0917") :method :outer("11_1275600002.0917") .param pmc param_544 .annotate 'line', 76 - .const 'Sub' $P553 = "38_1275511714.5903" + .const 'Sub' $P553 = "38_1275600002.0917" capture_lex $P553 new $P543, 'ExceptionHandler' set_addr $P543, control_542 @@ -9024,58 +9042,58 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes new $P545, "Undef" .lex "$past", $P545 find_lex $P546, "$/" - unless_null $P546, vivify_171 + unless_null $P546, vivify_172 $P546 = root_new ['parrot';'Hash'] - vivify_171: + vivify_172: set $P547, $P546["atom"] - unless_null $P547, vivify_172 + unless_null $P547, vivify_173 new $P547, "Undef" - vivify_172: + vivify_173: $P548 = $P547."ast"() store_lex "$past", $P548 .annotate 'line', 78 find_lex $P550, "$/" - unless_null $P550, vivify_173 + unless_null $P550, vivify_174 $P550 = root_new ['parrot';'Hash'] - vivify_173: + vivify_174: set $P551, $P550["quantifier"] - unless_null $P551, vivify_174 + unless_null $P551, vivify_175 new $P551, "Undef" - vivify_174: + vivify_175: if $P551, if_549 .annotate 'line', 84 find_lex $P568, "$/" - unless_null $P568, vivify_175 + unless_null $P568, vivify_176 $P568 = root_new ['parrot';'Hash'] - vivify_175: + vivify_176: set $P569, $P568["backmod"] - unless_null $P569, vivify_176 + unless_null $P569, vivify_177 $P569 = root_new ['parrot';'ResizablePMCArray'] - vivify_176: + vivify_177: set $P570, $P569[0] - unless_null $P570, vivify_177 + unless_null $P570, vivify_178 new $P570, "Undef" - vivify_177: + vivify_178: unless $P570, if_567_end find_lex $P571, "$past" find_lex $P572, "$/" - unless_null $P572, vivify_178 + unless_null $P572, vivify_179 $P572 = root_new ['parrot';'Hash'] - vivify_178: + vivify_179: set $P573, $P572["backmod"] - unless_null $P573, vivify_179 + unless_null $P573, vivify_180 $P573 = root_new ['parrot';'ResizablePMCArray'] - vivify_179: + vivify_180: set $P574, $P573[0] - unless_null $P574, vivify_180 + unless_null $P574, vivify_181 new $P574, "Undef" - vivify_180: + vivify_181: "backmod"($P571, $P574) if_567_end: goto if_549_end if_549: .annotate 'line', 78 - .const 'Sub' $P553 = "38_1275511714.5903" + .const 'Sub' $P553 = "38_1275600002.0917" capture_lex $P553 $P553() if_549_end: @@ -9096,17 +9114,17 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes goto if_577_end if_577: get_global $P584, "@MODIFIERS" - unless_null $P584, vivify_184 + unless_null $P584, vivify_185 $P584 = root_new ['parrot';'ResizablePMCArray'] - vivify_184: + vivify_185: set $P585, $P584[0] - unless_null $P585, vivify_185 + unless_null $P585, vivify_186 $P585 = root_new ['parrot';'Hash'] - vivify_185: + vivify_186: set $P586, $P585["r"] - unless_null $P586, vivify_186 + unless_null $P586, vivify_187 new $P586, "Undef" - vivify_186: + vivify_187: set $P576, $P586 if_577_end: unless $P576, if_575_end @@ -9129,7 +9147,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block552" :anon :subid("38_1275511714.5903") :outer("37_1275511714.5903") +.sub "_block552" :anon :subid("38_1275600002.0917") :outer("37_1275600002.0917") .annotate 'line', 80 new $P554, "Undef" .lex "$qast", $P554 @@ -9143,17 +9161,17 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes if_555_end: .annotate 'line', 80 find_lex $P560, "$/" - unless_null $P560, vivify_181 + unless_null $P560, vivify_182 $P560 = root_new ['parrot';'Hash'] - vivify_181: + vivify_182: set $P561, $P560["quantifier"] - unless_null $P561, vivify_182 + unless_null $P561, vivify_183 $P561 = root_new ['parrot';'ResizablePMCArray'] - vivify_182: + vivify_183: set $P562, $P561[0] - unless_null $P562, vivify_183 + unless_null $P562, vivify_184 new $P562, "Undef" - vivify_183: + vivify_184: $P563 = $P562."ast"() store_lex "$qast", $P563 .annotate 'line', 81 @@ -9169,7 +9187,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "atom" :subid("39_1275511714.5903") :method :outer("11_1275511714.5903") +.sub "atom" :subid("39_1275600002.0917") :method :outer("11_1275600002.0917") .param pmc param_595 .annotate 'line', 91 new $P594, 'ExceptionHandler' @@ -9185,13 +9203,13 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes find_lex $P597, "$past" .annotate 'line', 93 find_lex $P599, "$/" - unless_null $P599, vivify_187 + unless_null $P599, vivify_188 $P599 = root_new ['parrot';'Hash'] - vivify_187: + vivify_188: set $P600, $P599["metachar"] - unless_null $P600, vivify_188 + unless_null $P600, vivify_189 new $P600, "Undef" - vivify_188: + vivify_189: if $P600, if_598 .annotate 'line', 95 get_hll_global $P604, ["PAST"], "Regex" @@ -9202,17 +9220,17 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes store_lex "$past", $P608 .annotate 'line', 96 get_global $P610, "@MODIFIERS" - unless_null $P610, vivify_189 + unless_null $P610, vivify_190 $P610 = root_new ['parrot';'ResizablePMCArray'] - vivify_189: + vivify_190: set $P611, $P610[0] - unless_null $P611, vivify_190 + unless_null $P611, vivify_191 $P611 = root_new ['parrot';'Hash'] - vivify_190: + vivify_191: set $P612, $P611["i"] - unless_null $P612, vivify_191 + unless_null $P612, vivify_192 new $P612, "Undef" - vivify_191: + vivify_192: unless $P612, if_609_end find_lex $P613, "$past" $P613."subtype"("ignorecase") @@ -9222,13 +9240,13 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes if_598: .annotate 'line', 93 find_lex $P601, "$/" - unless_null $P601, vivify_192 + unless_null $P601, vivify_193 $P601 = root_new ['parrot';'Hash'] - vivify_192: + vivify_193: set $P602, $P601["metachar"] - unless_null $P602, vivify_193 + unless_null $P602, vivify_194 new $P602, "Undef" - vivify_193: + vivify_194: $P603 = $P602."ast"() store_lex "$past", $P603 if_598_end: @@ -9247,7 +9265,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "quantifier:sym<*>" :subid("40_1275511714.5903") :method :outer("11_1275511714.5903") +.sub "quantifier:sym<*>" :subid("40_1275600002.0917") :method :outer("11_1275600002.0917") .param pmc param_621 .annotate 'line', 101 new $P620, 'ExceptionHandler' @@ -9267,13 +9285,13 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes find_lex $P626, "$/" find_lex $P627, "$past" find_lex $P628, "$/" - unless_null $P628, vivify_194 + unless_null $P628, vivify_195 $P628 = root_new ['parrot';'Hash'] - vivify_194: + vivify_195: set $P629, $P628["backmod"] - unless_null $P629, vivify_195 + unless_null $P629, vivify_196 new $P629, "Undef" - vivify_195: + vivify_196: $P630 = "backmod"($P627, $P629) $P631 = $P626."!make"($P630) .annotate 'line', 101 @@ -9287,7 +9305,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "quantifier:sym<+>" :subid("41_1275511714.5903") :method :outer("11_1275511714.5903") +.sub "quantifier:sym<+>" :subid("41_1275600002.0917") :method :outer("11_1275600002.0917") .param pmc param_636 .annotate 'line', 106 new $P635, 'ExceptionHandler' @@ -9307,13 +9325,13 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes find_lex $P641, "$/" find_lex $P642, "$past" find_lex $P643, "$/" - unless_null $P643, vivify_196 + unless_null $P643, vivify_197 $P643 = root_new ['parrot';'Hash'] - vivify_196: + vivify_197: set $P644, $P643["backmod"] - unless_null $P644, vivify_197 + unless_null $P644, vivify_198 new $P644, "Undef" - vivify_197: + vivify_198: $P645 = "backmod"($P642, $P644) $P646 = $P641."!make"($P645) .annotate 'line', 106 @@ -9327,7 +9345,7 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "quantifier:sym" :subid("42_1275511714.5903") :method :outer("11_1275511714.5903") +.sub "quantifier:sym" :subid("42_1275600002.0917") :method :outer("11_1275600002.0917") .param pmc param_651 .annotate 'line', 111 new $P650, 'ExceptionHandler' @@ -9347,13 +9365,13 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes find_lex $P656, "$/" find_lex $P657, "$past" find_lex $P658, "$/" - unless_null $P658, vivify_198 + unless_null $P658, vivify_199 $P658 = root_new ['parrot';'Hash'] - vivify_198: + vivify_199: set $P659, $P658["backmod"] - unless_null $P659, vivify_199 + unless_null $P659, vivify_200 new $P659, "Undef" - vivify_199: + vivify_200: $P660 = "backmod"($P657, $P659) $P656."!make"($P660) .annotate 'line', 114 @@ -9371,9 +9389,11 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .namespace ["Regex";"P6Regex";"Actions"] -.sub "quantifier:sym<**>" :subid("43_1275511714.5903") :method :outer("11_1275511714.5903") +.sub "quantifier:sym<**>" :subid("43_1275600002.0917") :method :outer("11_1275600002.0917") .param pmc param_668 .annotate 'line', 117 + .const 'Sub' $P683 = "44_1275600002.0917" + capture_lex $P683 new $P667, 'ExceptionHandler' set_addr $P667, control_666 $P667."handle_types"(57) @@ -9383,2014 +9403,2083 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes .annotate 'line', 118 new $P669, "Undef" .lex "$past", $P669 +.annotate 'line', 119 + new $P670, "Undef" + .lex "$ws", $P670 .annotate 'line', 117 - find_lex $P670, "$past" + find_lex $P671, "$past" .annotate 'line', 119 - find_lex $P672, "$/" - unless_null $P672, vivify_200 - $P672 = root_new ['parrot';'Hash'] - vivify_200: - set $P673, $P672["quantified_atom"] - unless_null $P673, vivify_201 - new $P673, "Undef" + find_lex $P674, "$/" + unless_null $P674, vivify_201 + $P674 = root_new ['parrot';'Hash'] vivify_201: - if $P673, if_671 -.annotate 'line', 124 - get_hll_global $P680, ["PAST"], "Regex" - find_lex $P681, "$/" - unless_null $P681, vivify_202 - $P681 = root_new ['parrot';'Hash'] + set $P675, $P674["normspace"] + unless_null $P675, vivify_202 + new $P675, "Undef" vivify_202: - set $P682, $P681["min"] - unless_null $P682, vivify_203 - new $P682, "Undef" + if $P675, if_673 + set $P672, $P675 + goto if_673_end + if_673: + get_global $P676, "@MODIFIERS" + unless_null $P676, vivify_203 + $P676 = root_new ['parrot';'ResizablePMCArray'] vivify_203: - set $N683, $P682 - find_lex $P684, "$/" - $P685 = $P680."new"("quant" :named("pasttype"), $N683 :named("min"), $P684 :named("node")) - store_lex "$past", $P685 -.annotate 'line', 125 - find_lex $P687, "$/" - unless_null $P687, vivify_204 - $P687 = root_new ['parrot';'Hash'] + set $P677, $P676[0] + unless_null $P677, vivify_204 + $P677 = root_new ['parrot';'Hash'] vivify_204: - set $P688, $P687["max"] - unless_null $P688, vivify_205 - new $P688, "Undef" + set $P678, $P677["s"] + unless_null $P678, vivify_205 + new $P678, "Undef" vivify_205: - isfalse $I689, $P688 - if $I689, if_686 -.annotate 'line', 126 - find_lex $P695, "$/" - unless_null $P695, vivify_206 - $P695 = root_new ['parrot';'Hash'] + set $P672, $P678 + if_673_end: + store_lex "$ws", $P672 +.annotate 'line', 120 + find_lex $P680, "$/" + unless_null $P680, vivify_206 + $P680 = root_new ['parrot';'Hash'] vivify_206: - set $P696, $P695["max"] - unless_null $P696, vivify_207 - $P696 = root_new ['parrot';'ResizablePMCArray'] + set $P681, $P680["quantified_atom"] + unless_null $P681, vivify_207 + new $P681, "Undef" vivify_207: - set $P697, $P696[0] - unless_null $P697, vivify_208 - new $P697, "Undef" + if $P681, if_679 +.annotate 'line', 136 + get_hll_global $P701, ["PAST"], "Regex" + find_lex $P702, "$/" + unless_null $P702, vivify_208 + $P702 = root_new ['parrot';'Hash'] vivify_208: - set $S698, $P697 - isne $I699, $S698, "*" - unless $I699, if_694_end - find_lex $P700, "$past" - find_lex $P701, "$/" - unless_null $P701, vivify_209 - $P701 = root_new ['parrot';'Hash'] + set $P703, $P702["min"] + unless_null $P703, vivify_209 + new $P703, "Undef" vivify_209: - set $P702, $P701["max"] - unless_null $P702, vivify_210 - $P702 = root_new ['parrot';'ResizablePMCArray'] + set $N704, $P703 + find_lex $P705, "$/" + $P706 = $P701."new"("quant" :named("pasttype"), $N704 :named("min"), $P705 :named("node")) + store_lex "$past", $P706 +.annotate 'line', 137 + find_lex $P708, "$/" + unless_null $P708, vivify_210 + $P708 = root_new ['parrot';'Hash'] vivify_210: - set $P703, $P702[0] - unless_null $P703, vivify_211 - new $P703, "Undef" + set $P709, $P708["max"] + unless_null $P709, vivify_211 + new $P709, "Undef" vivify_211: - set $N704, $P703 - $P700."max"($N704) - if_694_end: - goto if_686_end - if_686: -.annotate 'line', 125 - find_lex $P690, "$past" - find_lex $P691, "$/" - unless_null $P691, vivify_212 - $P691 = root_new ['parrot';'Hash'] + isfalse $I710, $P709 + if $I710, if_707 +.annotate 'line', 138 + find_lex $P716, "$/" + unless_null $P716, vivify_212 + $P716 = root_new ['parrot';'Hash'] vivify_212: - set $P692, $P691["min"] - unless_null $P692, vivify_213 - new $P692, "Undef" + set $P717, $P716["max"] + unless_null $P717, vivify_213 + $P717 = root_new ['parrot';'ResizablePMCArray'] vivify_213: - set $N693, $P692 - $P690."max"($N693) - if_686_end: -.annotate 'line', 123 - goto if_671_end - if_671: -.annotate 'line', 120 - get_hll_global $P674, ["PAST"], "Regex" -.annotate 'line', 121 - find_lex $P675, "$/" - unless_null $P675, vivify_214 - $P675 = root_new ['parrot';'Hash'] + set $P718, $P717[0] + unless_null $P718, vivify_214 + new $P718, "Undef" vivify_214: - set $P676, $P675["quantified_atom"] - unless_null $P676, vivify_215 - new $P676, "Undef" + set $S719, $P718 + isne $I720, $S719, "*" + unless $I720, if_715_end + find_lex $P721, "$past" + find_lex $P722, "$/" + unless_null $P722, vivify_215 + $P722 = root_new ['parrot';'Hash'] vivify_215: - $P677 = $P676."ast"() - find_lex $P678, "$/" - $P679 = $P674."new"("quant" :named("pasttype"), 1 :named("min"), $P677 :named("sep"), $P678 :named("node")) -.annotate 'line', 120 - store_lex "$past", $P679 - if_671_end: -.annotate 'line', 128 - find_lex $P705, "$/" - find_lex $P706, "$past" - find_lex $P707, "$/" - unless_null $P707, vivify_216 - $P707 = root_new ['parrot';'Hash'] + set $P723, $P722["max"] + unless_null $P723, vivify_216 + $P723 = root_new ['parrot';'ResizablePMCArray'] vivify_216: - set $P708, $P707["backmod"] - unless_null $P708, vivify_217 - new $P708, "Undef" + set $P724, $P723[0] + unless_null $P724, vivify_217 + new $P724, "Undef" vivify_217: - $P709 = "backmod"($P706, $P708) - $P710 = $P705."!make"($P709) + set $N725, $P724 + $P721."max"($N725) + if_715_end: + goto if_707_end + if_707: +.annotate 'line', 137 + find_lex $P711, "$past" + find_lex $P712, "$/" + unless_null $P712, vivify_218 + $P712 = root_new ['parrot';'Hash'] + vivify_218: + set $P713, $P712["min"] + unless_null $P713, vivify_219 + new $P713, "Undef" + vivify_219: + set $N714, $P713 + $P711."max"($N714) + if_707_end: +.annotate 'line', 139 + find_lex $P727, "$ws" + unless $P727, if_726_end + find_lex $P728, "$past" + get_hll_global $P729, ["PAST"], "Regex" + $P730 = $P729."new"("ws", "subrule" :named("pasttype"), "method" :named("subtype")) + $P728."sep"($P730) + if_726_end: +.annotate 'line', 135 + goto if_679_end + if_679: +.annotate 'line', 120 + .const 'Sub' $P683 = "44_1275600002.0917" + capture_lex $P683 + $P683() + if_679_end: +.annotate 'line', 143 + find_lex $P731, "$/" + find_lex $P732, "$past" + find_lex $P733, "$/" + unless_null $P733, vivify_222 + $P733 = root_new ['parrot';'Hash'] + vivify_222: + set $P734, $P733["backmod"] + unless_null $P734, vivify_223 + new $P734, "Undef" + vivify_223: + $P735 = "backmod"($P732, $P734) + $P736 = $P731."!make"($P735) .annotate 'line', 117 - .return ($P710) + .return ($P736) control_666: .local pmc exception .get_results (exception) - getattribute $P711, exception, "payload" - .return ($P711) + getattribute $P737, exception, "payload" + .return ($P737) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym" :subid("44_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_715 -.annotate 'line', 131 - new $P714, 'ExceptionHandler' - set_addr $P714, control_713 - $P714."handle_types"(57) - push_eh $P714 - .lex "self", self - .lex "$/", param_715 -.annotate 'line', 132 - new $P716, "Undef" - .lex "$past", $P716 -.annotate 'line', 133 - get_global $P719, "@MODIFIERS" - unless_null $P719, vivify_218 - $P719 = root_new ['parrot';'ResizablePMCArray'] - vivify_218: - set $P720, $P719[0] - unless_null $P720, vivify_219 - $P720 = root_new ['parrot';'Hash'] - vivify_219: - set $P721, $P720["s"] - unless_null $P721, vivify_220 - new $P721, "Undef" +.sub "_block682" :anon :subid("44_1275600002.0917") :outer("43_1275600002.0917") +.annotate 'line', 121 + new $P684, "Undef" + .lex "$ast", $P684 + find_lex $P685, "$/" + unless_null $P685, vivify_220 + $P685 = root_new ['parrot';'Hash'] vivify_220: - if $P721, if_718 - new $P725, "Integer" - assign $P725, 0 - set $P717, $P725 - goto if_718_end - if_718: - get_hll_global $P722, ["PAST"], "Regex" - find_lex $P723, "$/" - $P724 = $P722."new"("ws", "subrule" :named("pasttype"), "method" :named("subtype"), $P723 :named("node")) - set $P717, $P724 - if_718_end: - store_lex "$past", $P717 -.annotate 'line', 136 - find_lex $P726, "$/" - find_lex $P727, "$past" - $P728 = $P726."!make"($P727) -.annotate 'line', 131 - .return ($P728) - control_713: - .local pmc exception - .get_results (exception) - getattribute $P729, exception, "payload" - .return ($P729) -.end - - -.namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym<[ ]>" :subid("45_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_733 -.annotate 'line', 140 - new $P732, 'ExceptionHandler' - set_addr $P732, control_731 - $P732."handle_types"(57) - push_eh $P732 - .lex "self", self - .lex "$/", param_733 -.annotate 'line', 141 - find_lex $P734, "$/" - find_lex $P735, "$/" - unless_null $P735, vivify_221 - $P735 = root_new ['parrot';'Hash'] + set $P686, $P685["quantified_atom"] + unless_null $P686, vivify_221 + new $P686, "Undef" vivify_221: - set $P736, $P735["nibbler"] - unless_null $P736, vivify_222 - new $P736, "Undef" - vivify_222: - $P737 = $P736."ast"() - $P738 = $P734."!make"($P737) -.annotate 'line', 140 - .return ($P738) - control_731: - .local pmc exception - .get_results (exception) - getattribute $P739, exception, "payload" - .return ($P739) + $P687 = $P686."ast"() + store_lex "$ast", $P687 +.annotate 'line', 122 + find_lex $P689, "$ws" + unless $P689, if_688_end +.annotate 'line', 123 + get_hll_global $P690, ["PAST"], "Regex" +.annotate 'line', 125 + get_hll_global $P691, ["PAST"], "Regex" + $P692 = $P691."new"("ws", "subrule" :named("pasttype"), "method" :named("subtype")) + find_lex $P693, "$ast" +.annotate 'line', 128 + get_hll_global $P694, ["PAST"], "Regex" + $P695 = $P694."new"("ws", "subrule" :named("pasttype"), "method" :named("subtype")) + $P696 = $P690."new"($P692, $P693, $P695, "concat" :named("pasttype")) +.annotate 'line', 123 + store_lex "$ast", $P696 + if_688_end: +.annotate 'line', 132 + get_hll_global $P697, ["PAST"], "Regex" + find_lex $P698, "$ast" + find_lex $P699, "$/" + $P700 = $P697."new"("quant" :named("pasttype"), 1 :named("min"), $P698 :named("sep"), $P699 :named("node")) + store_lex "$past", $P700 +.annotate 'line', 120 + .return ($P700) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym<( )>" :subid("46_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_743 -.annotate 'line', 144 - new $P742, 'ExceptionHandler' - set_addr $P742, control_741 - $P742."handle_types"(57) - push_eh $P742 - .lex "self", self - .lex "$/", param_743 -.annotate 'line', 145 - new $P744, "Undef" - .lex "$subpast", $P744 +.sub "metachar:sym" :subid("45_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_741 .annotate 'line', 146 - new $P745, "Undef" - .lex "$past", $P745 -.annotate 'line', 145 - find_lex $P746, "$/" - unless_null $P746, vivify_223 + new $P740, 'ExceptionHandler' + set_addr $P740, control_739 + $P740."handle_types"(57) + push_eh $P740 + .lex "self", self + .lex "$/", param_741 +.annotate 'line', 147 + new $P742, "Undef" + .lex "$past", $P742 +.annotate 'line', 148 + get_global $P745, "@MODIFIERS" + unless_null $P745, vivify_224 + $P745 = root_new ['parrot';'ResizablePMCArray'] + vivify_224: + set $P746, $P745[0] + unless_null $P746, vivify_225 $P746 = root_new ['parrot';'Hash'] - vivify_223: - set $P747, $P746["nibbler"] - unless_null $P747, vivify_224 + vivify_225: + set $P747, $P746["s"] + unless_null $P747, vivify_226 new $P747, "Undef" - vivify_224: - $P748 = $P747."ast"() - $P749 = "buildsub"($P748) - store_lex "$subpast", $P749 -.annotate 'line', 146 - get_hll_global $P750, ["PAST"], "Regex" - find_lex $P751, "$subpast" + vivify_226: + if $P747, if_744 + new $P751, "Integer" + assign $P751, 0 + set $P743, $P751 + goto if_744_end + if_744: + get_hll_global $P748, ["PAST"], "Regex" + find_lex $P749, "$/" + $P750 = $P748."new"("ws", "subrule" :named("pasttype"), "method" :named("subtype"), $P749 :named("node")) + set $P743, $P750 + if_744_end: + store_lex "$past", $P743 +.annotate 'line', 151 find_lex $P752, "$/" - $P753 = $P750."new"($P751, "subrule" :named("pasttype"), "capture" :named("subtype"), $P752 :named("node")) - store_lex "$past", $P753 -.annotate 'line', 148 - find_lex $P754, "$/" - find_lex $P755, "$past" - $P756 = $P754."!make"($P755) -.annotate 'line', 144 - .return ($P756) - control_741: + find_lex $P753, "$past" + $P754 = $P752."!make"($P753) +.annotate 'line', 146 + .return ($P754) + control_739: .local pmc exception .get_results (exception) - getattribute $P757, exception, "payload" - .return ($P757) + getattribute $P755, exception, "payload" + .return ($P755) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym<'>" :subid("47_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_761 -.annotate 'line', 151 - new $P760, 'ExceptionHandler' - set_addr $P760, control_759 - $P760."handle_types"(57) - push_eh $P760 +.sub "metachar:sym<[ ]>" :subid("46_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_759 +.annotate 'line', 155 + new $P758, 'ExceptionHandler' + set_addr $P758, control_757 + $P758."handle_types"(57) + push_eh $P758 .lex "self", self - .lex "$/", param_761 -.annotate 'line', 152 + .lex "$/", param_759 +.annotate 'line', 156 + find_lex $P760, "$/" + find_lex $P761, "$/" + unless_null $P761, vivify_227 + $P761 = root_new ['parrot';'Hash'] + vivify_227: + set $P762, $P761["nibbler"] + unless_null $P762, vivify_228 new $P762, "Undef" - .lex "$quote", $P762 -.annotate 'line', 154 - new $P763, "Undef" - .lex "$past", $P763 -.annotate 'line', 152 - find_lex $P764, "$/" - unless_null $P764, vivify_225 - $P764 = root_new ['parrot';'Hash'] - vivify_225: - set $P765, $P764["quote_EXPR"] - unless_null $P765, vivify_226 - new $P765, "Undef" - vivify_226: - $P766 = $P765."ast"() - store_lex "$quote", $P766 -.annotate 'line', 153 - get_hll_global $P768, ["PAST"], "Val" - find_lex $P769, "$quote" - $P770 = $P768."ACCEPTS"($P769) - unless $P770, if_767_end - find_lex $P771, "$quote" - $P772 = $P771."value"() - store_lex "$quote", $P772 - if_767_end: -.annotate 'line', 154 - get_hll_global $P773, ["PAST"], "Regex" - find_lex $P774, "$quote" - find_lex $P775, "$/" - $P776 = $P773."new"($P774, "literal" :named("pasttype"), $P775 :named("node")) - store_lex "$past", $P776 + vivify_228: + $P763 = $P762."ast"() + $P764 = $P760."!make"($P763) .annotate 'line', 155 - find_lex $P777, "$/" - find_lex $P778, "$past" - $P779 = $P777."!make"($P778) -.annotate 'line', 151 - .return ($P779) - control_759: + .return ($P764) + control_757: .local pmc exception .get_results (exception) - getattribute $P780, exception, "payload" - .return ($P780) + getattribute $P765, exception, "payload" + .return ($P765) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym<\">" :subid("48_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_784 -.annotate 'line', 158 - new $P783, 'ExceptionHandler' - set_addr $P783, control_782 - $P783."handle_types"(57) - push_eh $P783 - .lex "self", self - .lex "$/", param_784 +.sub "metachar:sym<( )>" :subid("47_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_769 .annotate 'line', 159 - new $P785, "Undef" - .lex "$quote", $P785 + new $P768, 'ExceptionHandler' + set_addr $P768, control_767 + $P768."handle_types"(57) + push_eh $P768 + .lex "self", self + .lex "$/", param_769 +.annotate 'line', 160 + new $P770, "Undef" + .lex "$subpast", $P770 .annotate 'line', 161 - new $P786, "Undef" - .lex "$past", $P786 -.annotate 'line', 159 - find_lex $P787, "$/" - unless_null $P787, vivify_227 - $P787 = root_new ['parrot';'Hash'] - vivify_227: - set $P788, $P787["quote_EXPR"] - unless_null $P788, vivify_228 - new $P788, "Undef" - vivify_228: - $P789 = $P788."ast"() - store_lex "$quote", $P789 + new $P771, "Undef" + .lex "$past", $P771 .annotate 'line', 160 - get_hll_global $P791, ["PAST"], "Val" - find_lex $P792, "$quote" - $P793 = $P791."ACCEPTS"($P792) - unless $P793, if_790_end - find_lex $P794, "$quote" - $P795 = $P794."value"() - store_lex "$quote", $P795 - if_790_end: + find_lex $P772, "$/" + unless_null $P772, vivify_229 + $P772 = root_new ['parrot';'Hash'] + vivify_229: + set $P773, $P772["nibbler"] + unless_null $P773, vivify_230 + new $P773, "Undef" + vivify_230: + $P774 = $P773."ast"() + $P775 = "buildsub"($P774) + store_lex "$subpast", $P775 .annotate 'line', 161 - get_hll_global $P796, ["PAST"], "Regex" - find_lex $P797, "$quote" - find_lex $P798, "$/" - $P799 = $P796."new"($P797, "literal" :named("pasttype"), $P798 :named("node")) - store_lex "$past", $P799 -.annotate 'line', 162 - find_lex $P800, "$/" - find_lex $P801, "$past" - $P802 = $P800."!make"($P801) -.annotate 'line', 158 - .return ($P802) - control_782: + get_hll_global $P776, ["PAST"], "Regex" + find_lex $P777, "$subpast" + find_lex $P778, "$/" + $P779 = $P776."new"($P777, "subrule" :named("pasttype"), "capture" :named("subtype"), $P778 :named("node")) + store_lex "$past", $P779 +.annotate 'line', 163 + find_lex $P780, "$/" + find_lex $P781, "$past" + $P782 = $P780."!make"($P781) +.annotate 'line', 159 + .return ($P782) + control_767: .local pmc exception .get_results (exception) - getattribute $P803, exception, "payload" - .return ($P803) + getattribute $P783, exception, "payload" + .return ($P783) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym<.>" :subid("49_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_807 -.annotate 'line', 165 - new $P806, 'ExceptionHandler' - set_addr $P806, control_805 - $P806."handle_types"(57) - push_eh $P806 - .lex "self", self - .lex "$/", param_807 +.sub "metachar:sym<'>" :subid("48_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_787 .annotate 'line', 166 - new $P808, "Undef" - .lex "$past", $P808 - get_hll_global $P809, ["PAST"], "Regex" - find_lex $P810, "$/" - $P811 = $P809."new"("charclass" :named("pasttype"), "." :named("subtype"), $P810 :named("node")) - store_lex "$past", $P811 -.annotate 'line', 167 - find_lex $P812, "$/" - find_lex $P813, "$past" - $P814 = $P812."!make"($P813) -.annotate 'line', 165 - .return ($P814) - control_805: - .local pmc exception - .get_results (exception) - getattribute $P815, exception, "payload" - .return ($P815) -.end - - -.namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym<^>" :subid("50_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_819 -.annotate 'line', 170 - new $P818, 'ExceptionHandler' - set_addr $P818, control_817 - $P818."handle_types"(57) - push_eh $P818 + new $P786, 'ExceptionHandler' + set_addr $P786, control_785 + $P786."handle_types"(57) + push_eh $P786 .lex "self", self - .lex "$/", param_819 -.annotate 'line', 171 - new $P820, "Undef" - .lex "$past", $P820 - get_hll_global $P821, ["PAST"], "Regex" - find_lex $P822, "$/" - $P823 = $P821."new"("anchor" :named("pasttype"), "bos" :named("subtype"), $P822 :named("node")) - store_lex "$past", $P823 -.annotate 'line', 172 - find_lex $P824, "$/" - find_lex $P825, "$past" - $P826 = $P824."!make"($P825) + .lex "$/", param_787 +.annotate 'line', 167 + new $P788, "Undef" + .lex "$quote", $P788 +.annotate 'line', 169 + new $P789, "Undef" + .lex "$past", $P789 +.annotate 'line', 167 + find_lex $P790, "$/" + unless_null $P790, vivify_231 + $P790 = root_new ['parrot';'Hash'] + vivify_231: + set $P791, $P790["quote_EXPR"] + unless_null $P791, vivify_232 + new $P791, "Undef" + vivify_232: + $P792 = $P791."ast"() + store_lex "$quote", $P792 +.annotate 'line', 168 + get_hll_global $P794, ["PAST"], "Val" + find_lex $P795, "$quote" + $P796 = $P794."ACCEPTS"($P795) + unless $P796, if_793_end + find_lex $P797, "$quote" + $P798 = $P797."value"() + store_lex "$quote", $P798 + if_793_end: +.annotate 'line', 169 + get_hll_global $P799, ["PAST"], "Regex" + find_lex $P800, "$quote" + find_lex $P801, "$/" + $P802 = $P799."new"($P800, "literal" :named("pasttype"), $P801 :named("node")) + store_lex "$past", $P802 .annotate 'line', 170 - .return ($P826) - control_817: + find_lex $P803, "$/" + find_lex $P804, "$past" + $P805 = $P803."!make"($P804) +.annotate 'line', 166 + .return ($P805) + control_785: .local pmc exception .get_results (exception) - getattribute $P827, exception, "payload" - .return ($P827) + getattribute $P806, exception, "payload" + .return ($P806) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym<^^>" :subid("51_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_831 -.annotate 'line', 175 - new $P830, 'ExceptionHandler' - set_addr $P830, control_829 - $P830."handle_types"(57) - push_eh $P830 +.sub "metachar:sym<\">" :subid("49_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_810 +.annotate 'line', 173 + new $P809, 'ExceptionHandler' + set_addr $P809, control_808 + $P809."handle_types"(57) + push_eh $P809 .lex "self", self - .lex "$/", param_831 + .lex "$/", param_810 +.annotate 'line', 174 + new $P811, "Undef" + .lex "$quote", $P811 .annotate 'line', 176 - new $P832, "Undef" - .lex "$past", $P832 - get_hll_global $P833, ["PAST"], "Regex" - find_lex $P834, "$/" - $P835 = $P833."new"("anchor" :named("pasttype"), "bol" :named("subtype"), $P834 :named("node")) - store_lex "$past", $P835 -.annotate 'line', 177 - find_lex $P836, "$/" - find_lex $P837, "$past" - $P838 = $P836."!make"($P837) + new $P812, "Undef" + .lex "$past", $P812 +.annotate 'line', 174 + find_lex $P813, "$/" + unless_null $P813, vivify_233 + $P813 = root_new ['parrot';'Hash'] + vivify_233: + set $P814, $P813["quote_EXPR"] + unless_null $P814, vivify_234 + new $P814, "Undef" + vivify_234: + $P815 = $P814."ast"() + store_lex "$quote", $P815 .annotate 'line', 175 - .return ($P838) - control_829: + get_hll_global $P817, ["PAST"], "Val" + find_lex $P818, "$quote" + $P819 = $P817."ACCEPTS"($P818) + unless $P819, if_816_end + find_lex $P820, "$quote" + $P821 = $P820."value"() + store_lex "$quote", $P821 + if_816_end: +.annotate 'line', 176 + get_hll_global $P822, ["PAST"], "Regex" + find_lex $P823, "$quote" + find_lex $P824, "$/" + $P825 = $P822."new"($P823, "literal" :named("pasttype"), $P824 :named("node")) + store_lex "$past", $P825 +.annotate 'line', 177 + find_lex $P826, "$/" + find_lex $P827, "$past" + $P828 = $P826."!make"($P827) +.annotate 'line', 173 + .return ($P828) + control_808: .local pmc exception .get_results (exception) - getattribute $P839, exception, "payload" - .return ($P839) + getattribute $P829, exception, "payload" + .return ($P829) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym<$>" :subid("52_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_843 +.sub "metachar:sym<.>" :subid("50_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_833 .annotate 'line', 180 - new $P842, 'ExceptionHandler' - set_addr $P842, control_841 - $P842."handle_types"(57) - push_eh $P842 + new $P832, 'ExceptionHandler' + set_addr $P832, control_831 + $P832."handle_types"(57) + push_eh $P832 .lex "self", self - .lex "$/", param_843 + .lex "$/", param_833 .annotate 'line', 181 - new $P844, "Undef" - .lex "$past", $P844 - get_hll_global $P845, ["PAST"], "Regex" - find_lex $P846, "$/" - $P847 = $P845."new"("anchor" :named("pasttype"), "eos" :named("subtype"), $P846 :named("node")) - store_lex "$past", $P847 + new $P834, "Undef" + .lex "$past", $P834 + get_hll_global $P835, ["PAST"], "Regex" + find_lex $P836, "$/" + $P837 = $P835."new"("charclass" :named("pasttype"), "." :named("subtype"), $P836 :named("node")) + store_lex "$past", $P837 .annotate 'line', 182 - find_lex $P848, "$/" - find_lex $P849, "$past" - $P850 = $P848."!make"($P849) + find_lex $P838, "$/" + find_lex $P839, "$past" + $P840 = $P838."!make"($P839) .annotate 'line', 180 - .return ($P850) - control_841: + .return ($P840) + control_831: .local pmc exception .get_results (exception) - getattribute $P851, exception, "payload" - .return ($P851) + getattribute $P841, exception, "payload" + .return ($P841) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym<$$>" :subid("53_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_855 +.sub "metachar:sym<^>" :subid("51_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_845 .annotate 'line', 185 - new $P854, 'ExceptionHandler' - set_addr $P854, control_853 - $P854."handle_types"(57) - push_eh $P854 + new $P844, 'ExceptionHandler' + set_addr $P844, control_843 + $P844."handle_types"(57) + push_eh $P844 .lex "self", self - .lex "$/", param_855 + .lex "$/", param_845 .annotate 'line', 186 - new $P856, "Undef" - .lex "$past", $P856 - get_hll_global $P857, ["PAST"], "Regex" - find_lex $P858, "$/" - $P859 = $P857."new"("anchor" :named("pasttype"), "eol" :named("subtype"), $P858 :named("node")) - store_lex "$past", $P859 + new $P846, "Undef" + .lex "$past", $P846 + get_hll_global $P847, ["PAST"], "Regex" + find_lex $P848, "$/" + $P849 = $P847."new"("anchor" :named("pasttype"), "bos" :named("subtype"), $P848 :named("node")) + store_lex "$past", $P849 .annotate 'line', 187 - find_lex $P860, "$/" - find_lex $P861, "$past" - $P862 = $P860."!make"($P861) + find_lex $P850, "$/" + find_lex $P851, "$past" + $P852 = $P850."!make"($P851) .annotate 'line', 185 - .return ($P862) - control_853: + .return ($P852) + control_843: .local pmc exception .get_results (exception) - getattribute $P863, exception, "payload" - .return ($P863) + getattribute $P853, exception, "payload" + .return ($P853) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym<:::>" :subid("54_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_867 +.sub "metachar:sym<^^>" :subid("52_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_857 .annotate 'line', 190 - new $P866, 'ExceptionHandler' - set_addr $P866, control_865 - $P866."handle_types"(57) - push_eh $P866 + new $P856, 'ExceptionHandler' + set_addr $P856, control_855 + $P856."handle_types"(57) + push_eh $P856 .lex "self", self - .lex "$/", param_867 + .lex "$/", param_857 .annotate 'line', 191 - new $P868, "Undef" - .lex "$past", $P868 - get_hll_global $P869, ["PAST"], "Regex" - find_lex $P870, "$/" - $P871 = $P869."new"("cut" :named("pasttype"), $P870 :named("node")) - store_lex "$past", $P871 + new $P858, "Undef" + .lex "$past", $P858 + get_hll_global $P859, ["PAST"], "Regex" + find_lex $P860, "$/" + $P861 = $P859."new"("anchor" :named("pasttype"), "bol" :named("subtype"), $P860 :named("node")) + store_lex "$past", $P861 .annotate 'line', 192 - find_lex $P872, "$/" - find_lex $P873, "$past" - $P874 = $P872."!make"($P873) + find_lex $P862, "$/" + find_lex $P863, "$past" + $P864 = $P862."!make"($P863) .annotate 'line', 190 - .return ($P874) - control_865: + .return ($P864) + control_855: .local pmc exception .get_results (exception) - getattribute $P875, exception, "payload" - .return ($P875) + getattribute $P865, exception, "payload" + .return ($P865) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym" :subid("55_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_879 +.sub "metachar:sym<$>" :subid("53_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_869 .annotate 'line', 195 - new $P878, 'ExceptionHandler' - set_addr $P878, control_877 - $P878."handle_types"(57) - push_eh $P878 + new $P868, 'ExceptionHandler' + set_addr $P868, control_867 + $P868."handle_types"(57) + push_eh $P868 .lex "self", self - .lex "$/", param_879 + .lex "$/", param_869 .annotate 'line', 196 - new $P880, "Undef" - .lex "$past", $P880 - get_hll_global $P881, ["PAST"], "Regex" - find_lex $P882, "$/" - $P883 = $P881."new"("anchor" :named("pasttype"), "lwb" :named("subtype"), $P882 :named("node")) - store_lex "$past", $P883 + new $P870, "Undef" + .lex "$past", $P870 + get_hll_global $P871, ["PAST"], "Regex" + find_lex $P872, "$/" + $P873 = $P871."new"("anchor" :named("pasttype"), "eos" :named("subtype"), $P872 :named("node")) + store_lex "$past", $P873 .annotate 'line', 197 - find_lex $P884, "$/" - find_lex $P885, "$past" - $P886 = $P884."!make"($P885) + find_lex $P874, "$/" + find_lex $P875, "$past" + $P876 = $P874."!make"($P875) .annotate 'line', 195 - .return ($P886) - control_877: + .return ($P876) + control_867: .local pmc exception .get_results (exception) - getattribute $P887, exception, "payload" - .return ($P887) + getattribute $P877, exception, "payload" + .return ($P877) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym" :subid("56_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_891 +.sub "metachar:sym<$$>" :subid("54_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_881 .annotate 'line', 200 - new $P890, 'ExceptionHandler' - set_addr $P890, control_889 - $P890."handle_types"(57) - push_eh $P890 + new $P880, 'ExceptionHandler' + set_addr $P880, control_879 + $P880."handle_types"(57) + push_eh $P880 .lex "self", self - .lex "$/", param_891 + .lex "$/", param_881 .annotate 'line', 201 - new $P892, "Undef" - .lex "$past", $P892 - get_hll_global $P893, ["PAST"], "Regex" - find_lex $P894, "$/" - $P895 = $P893."new"("anchor" :named("pasttype"), "rwb" :named("subtype"), $P894 :named("node")) - store_lex "$past", $P895 + new $P882, "Undef" + .lex "$past", $P882 + get_hll_global $P883, ["PAST"], "Regex" + find_lex $P884, "$/" + $P885 = $P883."new"("anchor" :named("pasttype"), "eol" :named("subtype"), $P884 :named("node")) + store_lex "$past", $P885 .annotate 'line', 202 - find_lex $P896, "$/" - find_lex $P897, "$past" - $P898 = $P896."!make"($P897) + find_lex $P886, "$/" + find_lex $P887, "$past" + $P888 = $P886."!make"($P887) .annotate 'line', 200 - .return ($P898) - control_889: + .return ($P888) + control_879: .local pmc exception .get_results (exception) - getattribute $P899, exception, "payload" - .return ($P899) + getattribute $P889, exception, "payload" + .return ($P889) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym" :subid("57_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_903 +.sub "metachar:sym<:::>" :subid("55_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_893 .annotate 'line', 205 - new $P902, 'ExceptionHandler' - set_addr $P902, control_901 - $P902."handle_types"(57) - push_eh $P902 + new $P892, 'ExceptionHandler' + set_addr $P892, control_891 + $P892."handle_types"(57) + push_eh $P892 .lex "self", self - .lex "$/", param_903 + .lex "$/", param_893 .annotate 'line', 206 - find_lex $P904, "$/" - find_lex $P905, "$/" - unless_null $P905, vivify_229 - $P905 = root_new ['parrot';'Hash'] - vivify_229: - set $P906, $P905["backslash"] - unless_null $P906, vivify_230 - new $P906, "Undef" - vivify_230: - $P907 = $P906."ast"() - $P908 = $P904."!make"($P907) + new $P894, "Undef" + .lex "$past", $P894 + get_hll_global $P895, ["PAST"], "Regex" + find_lex $P896, "$/" + $P897 = $P895."new"("cut" :named("pasttype"), $P896 :named("node")) + store_lex "$past", $P897 +.annotate 'line', 207 + find_lex $P898, "$/" + find_lex $P899, "$past" + $P900 = $P898."!make"($P899) .annotate 'line', 205 - .return ($P908) - control_901: + .return ($P900) + control_891: .local pmc exception .get_results (exception) - getattribute $P909, exception, "payload" - .return ($P909) + getattribute $P901, exception, "payload" + .return ($P901) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym" :subid("58_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_913 -.annotate 'line', 209 - new $P912, 'ExceptionHandler' - set_addr $P912, control_911 - $P912."handle_types"(57) - push_eh $P912 +.sub "metachar:sym" :subid("56_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_905 +.annotate 'line', 210 + new $P904, 'ExceptionHandler' + set_addr $P904, control_903 + $P904."handle_types"(57) + push_eh $P904 .lex "self", self - .lex "$/", param_913 + .lex "$/", param_905 +.annotate 'line', 211 + new $P906, "Undef" + .lex "$past", $P906 + get_hll_global $P907, ["PAST"], "Regex" + find_lex $P908, "$/" + $P909 = $P907."new"("anchor" :named("pasttype"), "lwb" :named("subtype"), $P908 :named("node")) + store_lex "$past", $P909 +.annotate 'line', 212 + find_lex $P910, "$/" + find_lex $P911, "$past" + $P912 = $P910."!make"($P911) .annotate 'line', 210 - find_lex $P914, "$/" - find_lex $P915, "$/" - unless_null $P915, vivify_231 - $P915 = root_new ['parrot';'Hash'] - vivify_231: - set $P916, $P915["mod_internal"] - unless_null $P916, vivify_232 - new $P916, "Undef" - vivify_232: - $P917 = $P916."ast"() - $P918 = $P914."!make"($P917) -.annotate 'line', 209 - .return ($P918) - control_911: + .return ($P912) + control_903: .local pmc exception .get_results (exception) - getattribute $P919, exception, "payload" - .return ($P919) + getattribute $P913, exception, "payload" + .return ($P913) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym" :subid("59_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_923 -.annotate 'line', 213 - new $P922, 'ExceptionHandler' - set_addr $P922, control_921 - $P922."handle_types"(57) - push_eh $P922 +.sub "metachar:sym" :subid("57_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_917 +.annotate 'line', 215 + new $P916, 'ExceptionHandler' + set_addr $P916, control_915 + $P916."handle_types"(57) + push_eh $P916 .lex "self", self - .lex "$/", param_923 -.annotate 'line', 214 - find_lex $P924, "$/" - find_lex $P925, "$/" - unless_null $P925, vivify_233 - $P925 = root_new ['parrot';'Hash'] - vivify_233: - set $P926, $P925["assertion"] - unless_null $P926, vivify_234 - new $P926, "Undef" - vivify_234: - $P927 = $P926."ast"() - $P928 = $P924."!make"($P927) -.annotate 'line', 213 - .return ($P928) - control_921: + .lex "$/", param_917 +.annotate 'line', 216 + new $P918, "Undef" + .lex "$past", $P918 + get_hll_global $P919, ["PAST"], "Regex" + find_lex $P920, "$/" + $P921 = $P919."new"("anchor" :named("pasttype"), "rwb" :named("subtype"), $P920 :named("node")) + store_lex "$past", $P921 +.annotate 'line', 217 + find_lex $P922, "$/" + find_lex $P923, "$past" + $P924 = $P922."!make"($P923) +.annotate 'line', 215 + .return ($P924) + control_915: .local pmc exception .get_results (exception) - getattribute $P929, exception, "payload" - .return ($P929) + getattribute $P925, exception, "payload" + .return ($P925) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym<~>" :subid("60_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_933 -.annotate 'line', 217 - new $P932, 'ExceptionHandler' - set_addr $P932, control_931 - $P932."handle_types"(57) - push_eh $P932 +.sub "metachar:sym" :subid("58_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_929 +.annotate 'line', 220 + new $P928, 'ExceptionHandler' + set_addr $P928, control_927 + $P928."handle_types"(57) + push_eh $P928 .lex "self", self - .lex "$/", param_933 -.annotate 'line', 218 - find_lex $P934, "$/" - get_hll_global $P935, ["PAST"], "Regex" -.annotate 'line', 219 - find_lex $P936, "$/" - unless_null $P936, vivify_235 - $P936 = root_new ['parrot';'Hash'] + .lex "$/", param_929 +.annotate 'line', 221 + find_lex $P930, "$/" + find_lex $P931, "$/" + unless_null $P931, vivify_235 + $P931 = root_new ['parrot';'Hash'] vivify_235: - set $P937, $P936["EXPR"] - unless_null $P937, vivify_236 - new $P937, "Undef" + set $P932, $P931["backslash"] + unless_null $P932, vivify_236 + new $P932, "Undef" vivify_236: - $P938 = $P937."ast"() + $P933 = $P932."ast"() + $P934 = $P930."!make"($P933) .annotate 'line', 220 - get_hll_global $P939, ["PAST"], "Regex" -.annotate 'line', 221 + .return ($P934) + control_927: + .local pmc exception + .get_results (exception) + getattribute $P935, exception, "payload" + .return ($P935) +.end + + +.namespace ["Regex";"P6Regex";"Actions"] +.sub "metachar:sym" :subid("59_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_939 +.annotate 'line', 224 + new $P938, 'ExceptionHandler' + set_addr $P938, control_937 + $P938."handle_types"(57) + push_eh $P938 + .lex "self", self + .lex "$/", param_939 +.annotate 'line', 225 find_lex $P940, "$/" - unless_null $P940, vivify_237 - $P940 = root_new ['parrot';'Hash'] + find_lex $P941, "$/" + unless_null $P941, vivify_237 + $P941 = root_new ['parrot';'Hash'] vivify_237: - set $P941, $P940["GOAL"] - unless_null $P941, vivify_238 - new $P941, "Undef" + set $P942, $P941["mod_internal"] + unless_null $P942, vivify_238 + new $P942, "Undef" vivify_238: - $P942 = $P941."ast"() -.annotate 'line', 222 - get_hll_global $P943, ["PAST"], "Regex" - find_lex $P944, "$/" - unless_null $P944, vivify_239 - $P944 = root_new ['parrot';'Hash'] + $P943 = $P942."ast"() + $P944 = $P940."!make"($P943) +.annotate 'line', 224 + .return ($P944) + control_937: + .local pmc exception + .get_results (exception) + getattribute $P945, exception, "payload" + .return ($P945) +.end + + +.namespace ["Regex";"P6Regex";"Actions"] +.sub "metachar:sym" :subid("60_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_949 +.annotate 'line', 228 + new $P948, 'ExceptionHandler' + set_addr $P948, control_947 + $P948."handle_types"(57) + push_eh $P948 + .lex "self", self + .lex "$/", param_949 +.annotate 'line', 229 + find_lex $P950, "$/" + find_lex $P951, "$/" + unless_null $P951, vivify_239 + $P951 = root_new ['parrot';'Hash'] vivify_239: - set $P945, $P944["GOAL"] - unless_null $P945, vivify_240 - new $P945, "Undef" + set $P952, $P951["assertion"] + unless_null $P952, vivify_240 + new $P952, "Undef" vivify_240: - set $S946, $P945 - $P947 = $P943."new"("FAILGOAL", $S946, "subrule" :named("pasttype"), "method" :named("subtype")) - $P948 = $P939."new"($P942, $P947, "alt" :named("pasttype")) -.annotate 'line', 220 - $P949 = $P935."new"($P938, $P948, "concat" :named("pasttype")) -.annotate 'line', 218 - $P950 = $P934."!make"($P949) -.annotate 'line', 217 - .return ($P950) - control_931: + $P953 = $P952."ast"() + $P954 = $P950."!make"($P953) +.annotate 'line', 228 + .return ($P954) + control_947: .local pmc exception .get_results (exception) - getattribute $P951, exception, "payload" - .return ($P951) + getattribute $P955, exception, "payload" + .return ($P955) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym<{*}>" :subid("61_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_955 -.annotate 'line', 230 - new $P954, 'ExceptionHandler' - set_addr $P954, control_953 - $P954."handle_types"(57) - push_eh $P954 - .lex "self", self - .lex "$/", param_955 -.annotate 'line', 231 - new $P956, "Undef" - .lex "$past", $P956 +.sub "metachar:sym<~>" :subid("61_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_959 .annotate 'line', 232 - find_lex $P959, "$/" - unless_null $P959, vivify_241 - $P959 = root_new ['parrot';'Hash'] - vivify_241: - set $P960, $P959["key"] - unless_null $P960, vivify_242 - new $P960, "Undef" - vivify_242: - if $P960, if_958 - new $P968, "Integer" - assign $P968, 0 - set $P957, $P968 - goto if_958_end - if_958: + new $P958, 'ExceptionHandler' + set_addr $P958, control_957 + $P958."handle_types"(57) + push_eh $P958 + .lex "self", self + .lex "$/", param_959 +.annotate 'line', 233 + find_lex $P960, "$/" get_hll_global $P961, ["PAST"], "Regex" +.annotate 'line', 234 find_lex $P962, "$/" - unless_null $P962, vivify_243 + unless_null $P962, vivify_241 $P962 = root_new ['parrot';'Hash'] + vivify_241: + set $P963, $P962["EXPR"] + unless_null $P963, vivify_242 + new $P963, "Undef" + vivify_242: + $P964 = $P963."ast"() +.annotate 'line', 235 + get_hll_global $P965, ["PAST"], "Regex" +.annotate 'line', 236 + find_lex $P966, "$/" + unless_null $P966, vivify_243 + $P966 = root_new ['parrot';'Hash'] vivify_243: - set $P963, $P962["key"] - unless_null $P963, vivify_244 - $P963 = root_new ['parrot';'ResizablePMCArray'] + set $P967, $P966["GOAL"] + unless_null $P967, vivify_244 + new $P967, "Undef" vivify_244: - set $P964, $P963[0] - unless_null $P964, vivify_245 - new $P964, "Undef" + $P968 = $P967."ast"() +.annotate 'line', 237 + get_hll_global $P969, ["PAST"], "Regex" + find_lex $P970, "$/" + unless_null $P970, vivify_245 + $P970 = root_new ['parrot';'Hash'] vivify_245: - set $S965, $P964 - find_lex $P966, "$/" - $P967 = $P961."new"($S965, "reduce" :named("pasttype"), $P966 :named("node")) - set $P957, $P967 - if_958_end: - store_lex "$past", $P957 -.annotate 'line', 234 - find_lex $P969, "$/" - find_lex $P970, "$past" - $P971 = $P969."!make"($P970) -.annotate 'line', 230 - .return ($P971) - control_953: + set $P971, $P970["GOAL"] + unless_null $P971, vivify_246 + new $P971, "Undef" + vivify_246: + set $S972, $P971 + $P973 = $P969."new"("FAILGOAL", $S972, "subrule" :named("pasttype"), "method" :named("subtype")) + $P974 = $P965."new"($P968, $P973, "alt" :named("pasttype")) +.annotate 'line', 235 + $P975 = $P961."new"($P964, $P974, "concat" :named("pasttype")) +.annotate 'line', 233 + $P976 = $P960."!make"($P975) +.annotate 'line', 232 + .return ($P976) + control_957: .local pmc exception .get_results (exception) - getattribute $P972, exception, "payload" - .return ($P972) + getattribute $P977, exception, "payload" + .return ($P977) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym" :subid("62_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_976 -.annotate 'line', 237 - new $P975, 'ExceptionHandler' - set_addr $P975, control_974 - $P975."handle_types"(57) - push_eh $P975 +.sub "metachar:sym<{*}>" :subid("62_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_981 +.annotate 'line', 245 + new $P980, 'ExceptionHandler' + set_addr $P980, control_979 + $P980."handle_types"(57) + push_eh $P980 .lex "self", self - .lex "$/", param_976 -.annotate 'line', 238 - new $P977, "Undef" - .lex "$past", $P977 -.annotate 'line', 239 - new $P978, "Undef" - .lex "$name", $P978 -.annotate 'line', 237 - find_lex $P979, "$past" -.annotate 'line', 239 - find_lex $P982, "$/" - unless_null $P982, vivify_246 - $P982 = root_new ['parrot';'Hash'] - vivify_246: - set $P983, $P982["pos"] - unless_null $P983, vivify_247 - new $P983, "Undef" + .lex "$/", param_981 +.annotate 'line', 246 + new $P982, "Undef" + .lex "$past", $P982 +.annotate 'line', 247 + find_lex $P985, "$/" + unless_null $P985, vivify_247 + $P985 = root_new ['parrot';'Hash'] vivify_247: - if $P983, if_981 - find_lex $P987, "$/" - unless_null $P987, vivify_248 - $P987 = root_new ['parrot';'Hash'] + set $P986, $P985["key"] + unless_null $P986, vivify_248 + new $P986, "Undef" vivify_248: - set $P988, $P987["name"] + if $P986, if_984 + new $P994, "Integer" + assign $P994, 0 + set $P983, $P994 + goto if_984_end + if_984: + get_hll_global $P987, ["PAST"], "Regex" + find_lex $P988, "$/" unless_null $P988, vivify_249 - new $P988, "Undef" + $P988 = root_new ['parrot';'Hash'] vivify_249: - set $S989, $P988 - new $P980, 'String' - set $P980, $S989 - goto if_981_end - if_981: - find_lex $P984, "$/" - unless_null $P984, vivify_250 - $P984 = root_new ['parrot';'Hash'] + set $P989, $P988["key"] + unless_null $P989, vivify_250 + $P989 = root_new ['parrot';'ResizablePMCArray'] vivify_250: - set $P985, $P984["pos"] - unless_null $P985, vivify_251 - new $P985, "Undef" + set $P990, $P989[0] + unless_null $P990, vivify_251 + new $P990, "Undef" vivify_251: - set $N986, $P985 - new $P980, 'Float' - set $P980, $N986 - if_981_end: - store_lex "$name", $P980 -.annotate 'line', 240 - find_lex $P991, "$/" - unless_null $P991, vivify_252 - $P991 = root_new ['parrot';'Hash'] + set $S991, $P990 + find_lex $P992, "$/" + $P993 = $P987."new"($S991, "reduce" :named("pasttype"), $P992 :named("node")) + set $P983, $P993 + if_984_end: + store_lex "$past", $P983 +.annotate 'line', 249 + find_lex $P995, "$/" + find_lex $P996, "$past" + $P997 = $P995."!make"($P996) +.annotate 'line', 245 + .return ($P997) + control_979: + .local pmc exception + .get_results (exception) + getattribute $P998, exception, "payload" + .return ($P998) +.end + + +.namespace ["Regex";"P6Regex";"Actions"] +.sub "metachar:sym" :subid("63_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1002 +.annotate 'line', 252 + new $P1001, 'ExceptionHandler' + set_addr $P1001, control_1000 + $P1001."handle_types"(57) + push_eh $P1001 + .lex "self", self + .lex "$/", param_1002 +.annotate 'line', 253 + new $P1003, "Undef" + .lex "$past", $P1003 +.annotate 'line', 254 + new $P1004, "Undef" + .lex "$name", $P1004 +.annotate 'line', 252 + find_lex $P1005, "$past" +.annotate 'line', 254 + find_lex $P1008, "$/" + unless_null $P1008, vivify_252 + $P1008 = root_new ['parrot';'Hash'] vivify_252: - set $P992, $P991["quantified_atom"] - unless_null $P992, vivify_253 - new $P992, "Undef" + set $P1009, $P1008["pos"] + unless_null $P1009, vivify_253 + new $P1009, "Undef" vivify_253: - if $P992, if_990 -.annotate 'line', 251 - get_hll_global $P1021, ["PAST"], "Regex" - find_lex $P1022, "$name" - find_lex $P1023, "$/" - $P1024 = $P1021."new"("!BACKREF", $P1022, "subrule" :named("pasttype"), "method" :named("subtype"), $P1023 :named("node")) - store_lex "$past", $P1024 -.annotate 'line', 250 - goto if_990_end - if_990: -.annotate 'line', 241 - find_lex $P993, "$/" - unless_null $P993, vivify_254 - $P993 = root_new ['parrot';'Hash'] + if $P1009, if_1007 + find_lex $P1013, "$/" + unless_null $P1013, vivify_254 + $P1013 = root_new ['parrot';'Hash'] vivify_254: - set $P994, $P993["quantified_atom"] - unless_null $P994, vivify_255 - $P994 = root_new ['parrot';'ResizablePMCArray'] + set $P1014, $P1013["name"] + unless_null $P1014, vivify_255 + new $P1014, "Undef" vivify_255: - set $P995, $P994[0] - unless_null $P995, vivify_256 - new $P995, "Undef" + set $S1015, $P1014 + new $P1006, 'String' + set $P1006, $S1015 + goto if_1007_end + if_1007: + find_lex $P1010, "$/" + unless_null $P1010, vivify_256 + $P1010 = root_new ['parrot';'Hash'] vivify_256: - $P996 = $P995."ast"() - store_lex "$past", $P996 -.annotate 'line', 242 - find_lex $P1000, "$past" - $S1001 = $P1000."pasttype"() - iseq $I1002, $S1001, "quant" - if $I1002, if_999 - new $P998, 'Integer' - set $P998, $I1002 - goto if_999_end - if_999: - find_lex $P1003, "$past" - unless_null $P1003, vivify_257 - $P1003 = root_new ['parrot';'ResizablePMCArray'] + set $P1011, $P1010["pos"] + unless_null $P1011, vivify_257 + new $P1011, "Undef" vivify_257: - set $P1004, $P1003[0] - unless_null $P1004, vivify_258 - new $P1004, "Undef" + set $N1012, $P1011 + new $P1006, 'Float' + set $P1006, $N1012 + if_1007_end: + store_lex "$name", $P1006 +.annotate 'line', 255 + find_lex $P1017, "$/" + unless_null $P1017, vivify_258 + $P1017 = root_new ['parrot';'Hash'] vivify_258: - $S1005 = $P1004."pasttype"() - iseq $I1006, $S1005, "subrule" - new $P998, 'Integer' - set $P998, $I1006 - if_999_end: - if $P998, if_997 -.annotate 'line', 245 - find_lex $P1011, "$past" - $S1012 = $P1011."pasttype"() - iseq $I1013, $S1012, "subrule" - if $I1013, if_1010 -.annotate 'line', 247 - get_hll_global $P1016, ["PAST"], "Regex" - find_lex $P1017, "$past" - find_lex $P1018, "$name" - find_lex $P1019, "$/" - $P1020 = $P1016."new"($P1017, $P1018 :named("name"), "subcapture" :named("pasttype"), $P1019 :named("node")) - store_lex "$past", $P1020 -.annotate 'line', 246 - goto if_1010_end - if_1010: -.annotate 'line', 245 - find_lex $P1014, "$past" - find_lex $P1015, "$name" - "subrule_alias"($P1014, $P1015) - if_1010_end: - goto if_997_end - if_997: -.annotate 'line', 243 - find_lex $P1007, "$past" - unless_null $P1007, vivify_259 - $P1007 = root_new ['parrot';'ResizablePMCArray'] + set $P1018, $P1017["quantified_atom"] + unless_null $P1018, vivify_259 + new $P1018, "Undef" vivify_259: - set $P1008, $P1007[0] - unless_null $P1008, vivify_260 - new $P1008, "Undef" + if $P1018, if_1016 +.annotate 'line', 266 + get_hll_global $P1047, ["PAST"], "Regex" + find_lex $P1048, "$name" + find_lex $P1049, "$/" + $P1050 = $P1047."new"("!BACKREF", $P1048, "subrule" :named("pasttype"), "method" :named("subtype"), $P1049 :named("node")) + store_lex "$past", $P1050 +.annotate 'line', 265 + goto if_1016_end + if_1016: +.annotate 'line', 256 + find_lex $P1019, "$/" + unless_null $P1019, vivify_260 + $P1019 = root_new ['parrot';'Hash'] vivify_260: - find_lex $P1009, "$name" - "subrule_alias"($P1008, $P1009) - if_997_end: - if_990_end: -.annotate 'line', 254 - find_lex $P1025, "$/" - find_lex $P1026, "$past" - $P1027 = $P1025."!make"($P1026) -.annotate 'line', 237 - .return ($P1027) - control_974: - .local pmc exception - .get_results (exception) - getattribute $P1028, exception, "payload" - .return ($P1028) -.end - - -.namespace ["Regex";"P6Regex";"Actions"] -.sub "metachar:sym" :subid("63_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1032 -.annotate 'line', 257 - new $P1031, 'ExceptionHandler' - set_addr $P1031, control_1030 - $P1031."handle_types"(57) - push_eh $P1031 - .lex "self", self - .lex "$/", param_1032 -.annotate 'line', 258 - find_lex $P1033, "$/" - get_hll_global $P1034, ["PAST"], "Regex" -.annotate 'line', 259 - get_hll_global $P1035, ["PAST"], "Op" - find_lex $P1036, "$/" - unless_null $P1036, vivify_261 - $P1036 = root_new ['parrot';'Hash'] + set $P1020, $P1019["quantified_atom"] + unless_null $P1020, vivify_261 + $P1020 = root_new ['parrot';'ResizablePMCArray'] vivify_261: - set $P1037, $P1036["pir"] - unless_null $P1037, vivify_262 - new $P1037, "Undef" + set $P1021, $P1020[0] + unless_null $P1021, vivify_262 + new $P1021, "Undef" vivify_262: - set $S1038, $P1037 - $P1039 = $P1035."new"($S1038 :named("inline"), "inline" :named("pasttype")) - find_lex $P1040, "$/" - $P1041 = $P1034."new"($P1039, "pastnode" :named("pasttype"), $P1040 :named("node")) -.annotate 'line', 258 - $P1042 = $P1033."!make"($P1041) + $P1022 = $P1021."ast"() + store_lex "$past", $P1022 .annotate 'line', 257 - .return ($P1042) - control_1030: - .local pmc exception - .get_results (exception) - getattribute $P1043, exception, "payload" - .return ($P1043) -.end - - -.namespace ["Regex";"P6Regex";"Actions"] -.sub "backslash:sym" :subid("64_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1047 -.annotate 'line', 265 - new $P1046, 'ExceptionHandler' - set_addr $P1046, control_1045 - $P1046."handle_types"(57) - push_eh $P1046 - .lex "self", self - .lex "$/", param_1047 -.annotate 'line', 266 - new $P1048, "Undef" - .lex "$subtype", $P1048 -.annotate 'line', 267 - new $P1049, "Undef" - .lex "$past", $P1049 -.annotate 'line', 266 - find_lex $P1052, "$/" - unless_null $P1052, vivify_263 - $P1052 = root_new ['parrot';'Hash'] + find_lex $P1026, "$past" + $S1027 = $P1026."pasttype"() + iseq $I1028, $S1027, "quant" + if $I1028, if_1025 + new $P1024, 'Integer' + set $P1024, $I1028 + goto if_1025_end + if_1025: + find_lex $P1029, "$past" + unless_null $P1029, vivify_263 + $P1029 = root_new ['parrot';'ResizablePMCArray'] vivify_263: - set $P1053, $P1052["sym"] - unless_null $P1053, vivify_264 - new $P1053, "Undef" + set $P1030, $P1029[0] + unless_null $P1030, vivify_264 + new $P1030, "Undef" vivify_264: - set $S1054, $P1053 - iseq $I1055, $S1054, "n" - if $I1055, if_1051 - find_lex $P1057, "$/" - unless_null $P1057, vivify_265 - $P1057 = root_new ['parrot';'Hash'] + $S1031 = $P1030."pasttype"() + iseq $I1032, $S1031, "subrule" + new $P1024, 'Integer' + set $P1024, $I1032 + if_1025_end: + if $P1024, if_1023 +.annotate 'line', 260 + find_lex $P1037, "$past" + $S1038 = $P1037."pasttype"() + iseq $I1039, $S1038, "subrule" + if $I1039, if_1036 +.annotate 'line', 262 + get_hll_global $P1042, ["PAST"], "Regex" + find_lex $P1043, "$past" + find_lex $P1044, "$name" + find_lex $P1045, "$/" + $P1046 = $P1042."new"($P1043, $P1044 :named("name"), "subcapture" :named("pasttype"), $P1045 :named("node")) + store_lex "$past", $P1046 +.annotate 'line', 261 + goto if_1036_end + if_1036: +.annotate 'line', 260 + find_lex $P1040, "$past" + find_lex $P1041, "$name" + "subrule_alias"($P1040, $P1041) + if_1036_end: + goto if_1023_end + if_1023: +.annotate 'line', 258 + find_lex $P1033, "$past" + unless_null $P1033, vivify_265 + $P1033 = root_new ['parrot';'ResizablePMCArray'] vivify_265: - set $P1058, $P1057["sym"] - unless_null $P1058, vivify_266 - new $P1058, "Undef" + set $P1034, $P1033[0] + unless_null $P1034, vivify_266 + new $P1034, "Undef" vivify_266: - set $S1059, $P1058 - new $P1050, 'String' - set $P1050, $S1059 - goto if_1051_end - if_1051: - new $P1056, "String" - assign $P1056, "nl" - set $P1050, $P1056 - if_1051_end: - store_lex "$subtype", $P1050 -.annotate 'line', 267 - get_hll_global $P1060, ["PAST"], "Regex" - find_lex $P1061, "$subtype" - find_lex $P1062, "$/" - $P1063 = $P1060."new"("charclass" :named("pasttype"), $P1061 :named("subtype"), $P1062 :named("node")) - store_lex "$past", $P1063 -.annotate 'line', 268 - find_lex $P1064, "$/" - find_lex $P1065, "$past" - $P1066 = $P1064."!make"($P1065) -.annotate 'line', 265 - .return ($P1066) - control_1045: + find_lex $P1035, "$name" + "subrule_alias"($P1034, $P1035) + if_1023_end: + if_1016_end: +.annotate 'line', 269 + find_lex $P1051, "$/" + find_lex $P1052, "$past" + $P1053 = $P1051."!make"($P1052) +.annotate 'line', 252 + .return ($P1053) + control_1000: .local pmc exception .get_results (exception) - getattribute $P1067, exception, "payload" - .return ($P1067) + getattribute $P1054, exception, "payload" + .return ($P1054) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "backslash:sym" :subid("65_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1071 -.annotate 'line', 271 - new $P1070, 'ExceptionHandler' - set_addr $P1070, control_1069 - $P1070."handle_types"(57) - push_eh $P1070 - .lex "self", self - .lex "$/", param_1071 +.sub "metachar:sym" :subid("64_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1058 .annotate 'line', 272 - new $P1072, "Undef" - .lex "$past", $P1072 - get_hll_global $P1073, ["PAST"], "Regex" + new $P1057, 'ExceptionHandler' + set_addr $P1057, control_1056 + $P1057."handle_types"(57) + push_eh $P1057 + .lex "self", self + .lex "$/", param_1058 .annotate 'line', 273 - find_lex $P1074, "$/" - unless_null $P1074, vivify_267 - $P1074 = root_new ['parrot';'Hash'] + find_lex $P1059, "$/" + get_hll_global $P1060, ["PAST"], "Regex" +.annotate 'line', 274 + get_hll_global $P1061, ["PAST"], "Op" + find_lex $P1062, "$/" + unless_null $P1062, vivify_267 + $P1062 = root_new ['parrot';'Hash'] vivify_267: - set $P1075, $P1074["sym"] - unless_null $P1075, vivify_268 - new $P1075, "Undef" + set $P1063, $P1062["pir"] + unless_null $P1063, vivify_268 + new $P1063, "Undef" vivify_268: - set $S1076, $P1075 - iseq $I1077, $S1076, "B" - find_lex $P1078, "$/" - $P1079 = $P1073."new"("\b", "enumcharlist" :named("pasttype"), $I1077 :named("negate"), $P1078 :named("node")) + set $S1064, $P1063 + $P1065 = $P1061."new"($S1064 :named("inline"), "inline" :named("pasttype")) + find_lex $P1066, "$/" + $P1067 = $P1060."new"($P1065, "pastnode" :named("pasttype"), $P1066 :named("node")) +.annotate 'line', 273 + $P1068 = $P1059."!make"($P1067) .annotate 'line', 272 - store_lex "$past", $P1079 -.annotate 'line', 274 - find_lex $P1080, "$/" - find_lex $P1081, "$past" - $P1082 = $P1080."!make"($P1081) -.annotate 'line', 271 - .return ($P1082) - control_1069: + .return ($P1068) + control_1056: .local pmc exception .get_results (exception) - getattribute $P1083, exception, "payload" - .return ($P1083) + getattribute $P1069, exception, "payload" + .return ($P1069) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "backslash:sym" :subid("66_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1087 -.annotate 'line', 277 - new $P1086, 'ExceptionHandler' - set_addr $P1086, control_1085 - $P1086."handle_types"(57) - push_eh $P1086 +.sub "backslash:sym" :subid("65_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1073 +.annotate 'line', 280 + new $P1072, 'ExceptionHandler' + set_addr $P1072, control_1071 + $P1072."handle_types"(57) + push_eh $P1072 .lex "self", self - .lex "$/", param_1087 -.annotate 'line', 278 - new $P1088, "Undef" - .lex "$past", $P1088 - get_hll_global $P1089, ["PAST"], "Regex" -.annotate 'line', 279 - find_lex $P1090, "$/" - unless_null $P1090, vivify_269 - $P1090 = root_new ['parrot';'Hash'] + .lex "$/", param_1073 +.annotate 'line', 281 + new $P1074, "Undef" + .lex "$subtype", $P1074 +.annotate 'line', 282 + new $P1075, "Undef" + .lex "$past", $P1075 +.annotate 'line', 281 + find_lex $P1078, "$/" + unless_null $P1078, vivify_269 + $P1078 = root_new ['parrot';'Hash'] vivify_269: - set $P1091, $P1090["sym"] - unless_null $P1091, vivify_270 - new $P1091, "Undef" + set $P1079, $P1078["sym"] + unless_null $P1079, vivify_270 + new $P1079, "Undef" vivify_270: - set $S1092, $P1091 - iseq $I1093, $S1092, "E" - find_lex $P1094, "$/" - $P1095 = $P1089."new"("\e", "enumcharlist" :named("pasttype"), $I1093 :named("negate"), $P1094 :named("node")) -.annotate 'line', 278 - store_lex "$past", $P1095 -.annotate 'line', 280 - find_lex $P1096, "$/" - find_lex $P1097, "$past" - $P1098 = $P1096."!make"($P1097) -.annotate 'line', 277 - .return ($P1098) - control_1085: - .local pmc exception - .get_results (exception) - getattribute $P1099, exception, "payload" - .return ($P1099) -.end - - -.namespace ["Regex";"P6Regex";"Actions"] -.sub "backslash:sym" :subid("67_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1103 -.annotate 'line', 283 - new $P1102, 'ExceptionHandler' - set_addr $P1102, control_1101 - $P1102."handle_types"(57) - push_eh $P1102 - .lex "self", self - .lex "$/", param_1103 -.annotate 'line', 284 - new $P1104, "Undef" - .lex "$past", $P1104 - get_hll_global $P1105, ["PAST"], "Regex" -.annotate 'line', 285 - find_lex $P1106, "$/" - unless_null $P1106, vivify_271 - $P1106 = root_new ['parrot';'Hash'] + set $S1080, $P1079 + iseq $I1081, $S1080, "n" + if $I1081, if_1077 + find_lex $P1083, "$/" + unless_null $P1083, vivify_271 + $P1083 = root_new ['parrot';'Hash'] vivify_271: - set $P1107, $P1106["sym"] - unless_null $P1107, vivify_272 - new $P1107, "Undef" + set $P1084, $P1083["sym"] + unless_null $P1084, vivify_272 + new $P1084, "Undef" vivify_272: - set $S1108, $P1107 - iseq $I1109, $S1108, "F" - find_lex $P1110, "$/" - $P1111 = $P1105."new"("\f", "enumcharlist" :named("pasttype"), $I1109 :named("negate"), $P1110 :named("node")) -.annotate 'line', 284 - store_lex "$past", $P1111 -.annotate 'line', 286 - find_lex $P1112, "$/" - find_lex $P1113, "$past" - $P1114 = $P1112."!make"($P1113) + set $S1085, $P1084 + new $P1076, 'String' + set $P1076, $S1085 + goto if_1077_end + if_1077: + new $P1082, "String" + assign $P1082, "nl" + set $P1076, $P1082 + if_1077_end: + store_lex "$subtype", $P1076 +.annotate 'line', 282 + get_hll_global $P1086, ["PAST"], "Regex" + find_lex $P1087, "$subtype" + find_lex $P1088, "$/" + $P1089 = $P1086."new"("charclass" :named("pasttype"), $P1087 :named("subtype"), $P1088 :named("node")) + store_lex "$past", $P1089 .annotate 'line', 283 - .return ($P1114) - control_1101: + find_lex $P1090, "$/" + find_lex $P1091, "$past" + $P1092 = $P1090."!make"($P1091) +.annotate 'line', 280 + .return ($P1092) + control_1071: .local pmc exception .get_results (exception) - getattribute $P1115, exception, "payload" - .return ($P1115) + getattribute $P1093, exception, "payload" + .return ($P1093) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "backslash:sym" :subid("68_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1119 -.annotate 'line', 289 - new $P1118, 'ExceptionHandler' - set_addr $P1118, control_1117 - $P1118."handle_types"(57) - push_eh $P1118 +.sub "backslash:sym" :subid("66_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1097 +.annotate 'line', 286 + new $P1096, 'ExceptionHandler' + set_addr $P1096, control_1095 + $P1096."handle_types"(57) + push_eh $P1096 .lex "self", self - .lex "$/", param_1119 -.annotate 'line', 290 - new $P1120, "Undef" - .lex "$past", $P1120 - get_hll_global $P1121, ["PAST"], "Regex" -.annotate 'line', 291 - find_lex $P1122, "$/" - unless_null $P1122, vivify_273 - $P1122 = root_new ['parrot';'Hash'] + .lex "$/", param_1097 +.annotate 'line', 287 + new $P1098, "Undef" + .lex "$past", $P1098 + get_hll_global $P1099, ["PAST"], "Regex" +.annotate 'line', 288 + find_lex $P1100, "$/" + unless_null $P1100, vivify_273 + $P1100 = root_new ['parrot';'Hash'] vivify_273: - set $P1123, $P1122["sym"] - unless_null $P1123, vivify_274 - new $P1123, "Undef" + set $P1101, $P1100["sym"] + unless_null $P1101, vivify_274 + new $P1101, "Undef" vivify_274: - set $S1124, $P1123 - iseq $I1125, $S1124, "H" - find_lex $P1126, "$/" - $P1127 = $P1121."new"(unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", "enumcharlist" :named("pasttype"), $I1125 :named("negate"), $P1126 :named("node")) -.annotate 'line', 290 - store_lex "$past", $P1127 -.annotate 'line', 292 - find_lex $P1128, "$/" - find_lex $P1129, "$past" - $P1130 = $P1128."!make"($P1129) + set $S1102, $P1101 + iseq $I1103, $S1102, "B" + find_lex $P1104, "$/" + $P1105 = $P1099."new"("\b", "enumcharlist" :named("pasttype"), $I1103 :named("negate"), $P1104 :named("node")) +.annotate 'line', 287 + store_lex "$past", $P1105 .annotate 'line', 289 - .return ($P1130) - control_1117: + find_lex $P1106, "$/" + find_lex $P1107, "$past" + $P1108 = $P1106."!make"($P1107) +.annotate 'line', 286 + .return ($P1108) + control_1095: .local pmc exception .get_results (exception) - getattribute $P1131, exception, "payload" - .return ($P1131) + getattribute $P1109, exception, "payload" + .return ($P1109) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "backslash:sym" :subid("69_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1135 -.annotate 'line', 295 - new $P1134, 'ExceptionHandler' - set_addr $P1134, control_1133 - $P1134."handle_types"(57) - push_eh $P1134 +.sub "backslash:sym" :subid("67_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1113 +.annotate 'line', 292 + new $P1112, 'ExceptionHandler' + set_addr $P1112, control_1111 + $P1112."handle_types"(57) + push_eh $P1112 .lex "self", self - .lex "$/", param_1135 -.annotate 'line', 296 - new $P1136, "Undef" - .lex "$past", $P1136 - get_hll_global $P1137, ["PAST"], "Regex" -.annotate 'line', 297 - find_lex $P1138, "$/" - unless_null $P1138, vivify_275 - $P1138 = root_new ['parrot';'Hash'] + .lex "$/", param_1113 +.annotate 'line', 293 + new $P1114, "Undef" + .lex "$past", $P1114 + get_hll_global $P1115, ["PAST"], "Regex" +.annotate 'line', 294 + find_lex $P1116, "$/" + unless_null $P1116, vivify_275 + $P1116 = root_new ['parrot';'Hash'] vivify_275: - set $P1139, $P1138["sym"] - unless_null $P1139, vivify_276 - new $P1139, "Undef" + set $P1117, $P1116["sym"] + unless_null $P1117, vivify_276 + new $P1117, "Undef" vivify_276: - set $S1140, $P1139 - iseq $I1141, $S1140, "R" - find_lex $P1142, "$/" - $P1143 = $P1137."new"("\r", "enumcharlist" :named("pasttype"), $I1141 :named("negate"), $P1142 :named("node")) -.annotate 'line', 296 - store_lex "$past", $P1143 -.annotate 'line', 298 - find_lex $P1144, "$/" - find_lex $P1145, "$past" - $P1146 = $P1144."!make"($P1145) + set $S1118, $P1117 + iseq $I1119, $S1118, "E" + find_lex $P1120, "$/" + $P1121 = $P1115."new"("\e", "enumcharlist" :named("pasttype"), $I1119 :named("negate"), $P1120 :named("node")) +.annotate 'line', 293 + store_lex "$past", $P1121 .annotate 'line', 295 - .return ($P1146) - control_1133: + find_lex $P1122, "$/" + find_lex $P1123, "$past" + $P1124 = $P1122."!make"($P1123) +.annotate 'line', 292 + .return ($P1124) + control_1111: .local pmc exception .get_results (exception) - getattribute $P1147, exception, "payload" - .return ($P1147) + getattribute $P1125, exception, "payload" + .return ($P1125) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "backslash:sym" :subid("70_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1151 -.annotate 'line', 301 - new $P1150, 'ExceptionHandler' - set_addr $P1150, control_1149 - $P1150."handle_types"(57) - push_eh $P1150 +.sub "backslash:sym" :subid("68_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1129 +.annotate 'line', 298 + new $P1128, 'ExceptionHandler' + set_addr $P1128, control_1127 + $P1128."handle_types"(57) + push_eh $P1128 .lex "self", self - .lex "$/", param_1151 -.annotate 'line', 302 - new $P1152, "Undef" - .lex "$past", $P1152 - get_hll_global $P1153, ["PAST"], "Regex" -.annotate 'line', 303 - find_lex $P1154, "$/" - unless_null $P1154, vivify_277 - $P1154 = root_new ['parrot';'Hash'] + .lex "$/", param_1129 +.annotate 'line', 299 + new $P1130, "Undef" + .lex "$past", $P1130 + get_hll_global $P1131, ["PAST"], "Regex" +.annotate 'line', 300 + find_lex $P1132, "$/" + unless_null $P1132, vivify_277 + $P1132 = root_new ['parrot';'Hash'] vivify_277: - set $P1155, $P1154["sym"] - unless_null $P1155, vivify_278 - new $P1155, "Undef" + set $P1133, $P1132["sym"] + unless_null $P1133, vivify_278 + new $P1133, "Undef" vivify_278: - set $S1156, $P1155 - iseq $I1157, $S1156, "T" - find_lex $P1158, "$/" - $P1159 = $P1153."new"("\t", "enumcharlist" :named("pasttype"), $I1157 :named("negate"), $P1158 :named("node")) -.annotate 'line', 302 - store_lex "$past", $P1159 -.annotate 'line', 304 - find_lex $P1160, "$/" - find_lex $P1161, "$past" - $P1162 = $P1160."!make"($P1161) + set $S1134, $P1133 + iseq $I1135, $S1134, "F" + find_lex $P1136, "$/" + $P1137 = $P1131."new"("\f", "enumcharlist" :named("pasttype"), $I1135 :named("negate"), $P1136 :named("node")) +.annotate 'line', 299 + store_lex "$past", $P1137 .annotate 'line', 301 - .return ($P1162) - control_1149: + find_lex $P1138, "$/" + find_lex $P1139, "$past" + $P1140 = $P1138."!make"($P1139) +.annotate 'line', 298 + .return ($P1140) + control_1127: .local pmc exception .get_results (exception) - getattribute $P1163, exception, "payload" - .return ($P1163) + getattribute $P1141, exception, "payload" + .return ($P1141) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "backslash:sym" :subid("71_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1167 -.annotate 'line', 307 - new $P1166, 'ExceptionHandler' - set_addr $P1166, control_1165 - $P1166."handle_types"(57) - push_eh $P1166 +.sub "backslash:sym" :subid("69_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1145 +.annotate 'line', 304 + new $P1144, 'ExceptionHandler' + set_addr $P1144, control_1143 + $P1144."handle_types"(57) + push_eh $P1144 .lex "self", self - .lex "$/", param_1167 -.annotate 'line', 308 - new $P1168, "Undef" - .lex "$past", $P1168 - get_hll_global $P1169, ["PAST"], "Regex" -.annotate 'line', 310 - find_lex $P1170, "$/" - unless_null $P1170, vivify_279 - $P1170 = root_new ['parrot';'Hash'] + .lex "$/", param_1145 +.annotate 'line', 305 + new $P1146, "Undef" + .lex "$past", $P1146 + get_hll_global $P1147, ["PAST"], "Regex" +.annotate 'line', 306 + find_lex $P1148, "$/" + unless_null $P1148, vivify_279 + $P1148 = root_new ['parrot';'Hash'] vivify_279: - set $P1171, $P1170["sym"] - unless_null $P1171, vivify_280 - new $P1171, "Undef" + set $P1149, $P1148["sym"] + unless_null $P1149, vivify_280 + new $P1149, "Undef" vivify_280: - set $S1172, $P1171 - iseq $I1173, $S1172, "V" - find_lex $P1174, "$/" - $P1175 = $P1169."new"(unicode:"\n\x{b}\f\r\x{85}\u2028\u2029", "enumcharlist" :named("pasttype"), $I1173 :named("negate"), $P1174 :named("node")) -.annotate 'line', 308 - store_lex "$past", $P1175 -.annotate 'line', 311 - find_lex $P1176, "$/" - find_lex $P1177, "$past" - $P1178 = $P1176."!make"($P1177) + set $S1150, $P1149 + iseq $I1151, $S1150, "H" + find_lex $P1152, "$/" + $P1153 = $P1147."new"(unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", "enumcharlist" :named("pasttype"), $I1151 :named("negate"), $P1152 :named("node")) +.annotate 'line', 305 + store_lex "$past", $P1153 .annotate 'line', 307 - .return ($P1178) - control_1165: + find_lex $P1154, "$/" + find_lex $P1155, "$past" + $P1156 = $P1154."!make"($P1155) +.annotate 'line', 304 + .return ($P1156) + control_1143: .local pmc exception .get_results (exception) - getattribute $P1179, exception, "payload" - .return ($P1179) + getattribute $P1157, exception, "payload" + .return ($P1157) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "backslash:sym" :subid("72_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1183 -.annotate 'line', 314 - new $P1182, 'ExceptionHandler' - set_addr $P1182, control_1181 - $P1182."handle_types"(57) - push_eh $P1182 +.sub "backslash:sym" :subid("70_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1161 +.annotate 'line', 310 + new $P1160, 'ExceptionHandler' + set_addr $P1160, control_1159 + $P1160."handle_types"(57) + push_eh $P1160 .lex "self", self - .lex "$/", param_1183 -.annotate 'line', 315 - new $P1184, "Undef" - .lex "$octlit", $P1184 -.annotate 'line', 316 - get_hll_global $P1185, ["HLL";"Actions"], "ints_to_string" - find_lex $P1188, "$/" - unless_null $P1188, vivify_281 - $P1188 = root_new ['parrot';'Hash'] + .lex "$/", param_1161 +.annotate 'line', 311 + new $P1162, "Undef" + .lex "$past", $P1162 + get_hll_global $P1163, ["PAST"], "Regex" +.annotate 'line', 312 + find_lex $P1164, "$/" + unless_null $P1164, vivify_281 + $P1164 = root_new ['parrot';'Hash'] vivify_281: - set $P1189, $P1188["octint"] - unless_null $P1189, vivify_282 - new $P1189, "Undef" + set $P1165, $P1164["sym"] + unless_null $P1165, vivify_282 + new $P1165, "Undef" vivify_282: - unless $P1189, unless_1187 - set $P1186, $P1189 - goto unless_1187_end - unless_1187: - find_lex $P1190, "$/" - unless_null $P1190, vivify_283 - $P1190 = root_new ['parrot';'Hash'] + set $S1166, $P1165 + iseq $I1167, $S1166, "R" + find_lex $P1168, "$/" + $P1169 = $P1163."new"("\r", "enumcharlist" :named("pasttype"), $I1167 :named("negate"), $P1168 :named("node")) +.annotate 'line', 311 + store_lex "$past", $P1169 +.annotate 'line', 313 + find_lex $P1170, "$/" + find_lex $P1171, "$past" + $P1172 = $P1170."!make"($P1171) +.annotate 'line', 310 + .return ($P1172) + control_1159: + .local pmc exception + .get_results (exception) + getattribute $P1173, exception, "payload" + .return ($P1173) +.end + + +.namespace ["Regex";"P6Regex";"Actions"] +.sub "backslash:sym" :subid("71_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1177 +.annotate 'line', 316 + new $P1176, 'ExceptionHandler' + set_addr $P1176, control_1175 + $P1176."handle_types"(57) + push_eh $P1176 + .lex "self", self + .lex "$/", param_1177 +.annotate 'line', 317 + new $P1178, "Undef" + .lex "$past", $P1178 + get_hll_global $P1179, ["PAST"], "Regex" +.annotate 'line', 318 + find_lex $P1180, "$/" + unless_null $P1180, vivify_283 + $P1180 = root_new ['parrot';'Hash'] vivify_283: - set $P1191, $P1190["octints"] - unless_null $P1191, vivify_284 - $P1191 = root_new ['parrot';'Hash'] + set $P1181, $P1180["sym"] + unless_null $P1181, vivify_284 + new $P1181, "Undef" vivify_284: - set $P1192, $P1191["octint"] - unless_null $P1192, vivify_285 - new $P1192, "Undef" - vivify_285: - set $P1186, $P1192 - unless_1187_end: - $P1193 = $P1185($P1186) - store_lex "$octlit", $P1193 + set $S1182, $P1181 + iseq $I1183, $S1182, "T" + find_lex $P1184, "$/" + $P1185 = $P1179."new"("\t", "enumcharlist" :named("pasttype"), $I1183 :named("negate"), $P1184 :named("node")) .annotate 'line', 317 - find_lex $P1194, "$/" - find_lex $P1197, "$/" + store_lex "$past", $P1185 +.annotate 'line', 319 + find_lex $P1186, "$/" + find_lex $P1187, "$past" + $P1188 = $P1186."!make"($P1187) +.annotate 'line', 316 + .return ($P1188) + control_1175: + .local pmc exception + .get_results (exception) + getattribute $P1189, exception, "payload" + .return ($P1189) +.end + + +.namespace ["Regex";"P6Regex";"Actions"] +.sub "backslash:sym" :subid("72_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1193 +.annotate 'line', 322 + new $P1192, 'ExceptionHandler' + set_addr $P1192, control_1191 + $P1192."handle_types"(57) + push_eh $P1192 + .lex "self", self + .lex "$/", param_1193 +.annotate 'line', 323 + new $P1194, "Undef" + .lex "$past", $P1194 + get_hll_global $P1195, ["PAST"], "Regex" +.annotate 'line', 325 + find_lex $P1196, "$/" + unless_null $P1196, vivify_285 + $P1196 = root_new ['parrot';'Hash'] + vivify_285: + set $P1197, $P1196["sym"] unless_null $P1197, vivify_286 - $P1197 = root_new ['parrot';'Hash'] + new $P1197, "Undef" vivify_286: - set $P1198, $P1197["sym"] - unless_null $P1198, vivify_287 - new $P1198, "Undef" - vivify_287: - set $S1199, $P1198 - iseq $I1200, $S1199, "O" - if $I1200, if_1196 -.annotate 'line', 320 - get_hll_global $P1205, ["PAST"], "Regex" - find_lex $P1206, "$octlit" - find_lex $P1207, "$/" - $P1208 = $P1205."new"($P1206, "literal" :named("pasttype"), $P1207 :named("node")) - set $P1195, $P1208 -.annotate 'line', 317 - goto if_1196_end - if_1196: -.annotate 'line', 318 - get_hll_global $P1201, ["PAST"], "Regex" - find_lex $P1202, "$octlit" - find_lex $P1203, "$/" - $P1204 = $P1201."new"($P1202, "enumcharlist" :named("pasttype"), 1 :named("negate"), $P1203 :named("node")) - set $P1195, $P1204 - if_1196_end: - $P1209 = $P1194."!make"($P1195) -.annotate 'line', 314 - .return ($P1209) - control_1181: + set $S1198, $P1197 + iseq $I1199, $S1198, "V" + find_lex $P1200, "$/" + $P1201 = $P1195."new"(unicode:"\n\x{b}\f\r\x{85}\u2028\u2029", "enumcharlist" :named("pasttype"), $I1199 :named("negate"), $P1200 :named("node")) +.annotate 'line', 323 + store_lex "$past", $P1201 +.annotate 'line', 326 + find_lex $P1202, "$/" + find_lex $P1203, "$past" + $P1204 = $P1202."!make"($P1203) +.annotate 'line', 322 + .return ($P1204) + control_1191: .local pmc exception .get_results (exception) - getattribute $P1210, exception, "payload" - .return ($P1210) + getattribute $P1205, exception, "payload" + .return ($P1205) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "backslash:sym" :subid("73_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1214 -.annotate 'line', 323 - new $P1213, 'ExceptionHandler' - set_addr $P1213, control_1212 - $P1213."handle_types"(57) - push_eh $P1213 +.sub "backslash:sym" :subid("73_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1209 +.annotate 'line', 329 + new $P1208, 'ExceptionHandler' + set_addr $P1208, control_1207 + $P1208."handle_types"(57) + push_eh $P1208 .lex "self", self - .lex "$/", param_1214 -.annotate 'line', 324 + .lex "$/", param_1209 +.annotate 'line', 330 + new $P1210, "Undef" + .lex "$octlit", $P1210 +.annotate 'line', 331 + get_hll_global $P1211, ["HLL";"Actions"], "ints_to_string" + find_lex $P1214, "$/" + unless_null $P1214, vivify_287 + $P1214 = root_new ['parrot';'Hash'] + vivify_287: + set $P1215, $P1214["octint"] + unless_null $P1215, vivify_288 new $P1215, "Undef" - .lex "$hexlit", $P1215 -.annotate 'line', 325 - get_hll_global $P1216, ["HLL";"Actions"], "ints_to_string" - find_lex $P1219, "$/" - unless_null $P1219, vivify_288 - $P1219 = root_new ['parrot';'Hash'] vivify_288: - set $P1220, $P1219["hexint"] - unless_null $P1220, vivify_289 - new $P1220, "Undef" + unless $P1215, unless_1213 + set $P1212, $P1215 + goto unless_1213_end + unless_1213: + find_lex $P1216, "$/" + unless_null $P1216, vivify_289 + $P1216 = root_new ['parrot';'Hash'] vivify_289: - unless $P1220, unless_1218 - set $P1217, $P1220 - goto unless_1218_end - unless_1218: - find_lex $P1221, "$/" - unless_null $P1221, vivify_290 - $P1221 = root_new ['parrot';'Hash'] + set $P1217, $P1216["octints"] + unless_null $P1217, vivify_290 + $P1217 = root_new ['parrot';'Hash'] vivify_290: - set $P1222, $P1221["hexints"] - unless_null $P1222, vivify_291 - $P1222 = root_new ['parrot';'Hash'] + set $P1218, $P1217["octint"] + unless_null $P1218, vivify_291 + new $P1218, "Undef" vivify_291: - set $P1223, $P1222["hexint"] + set $P1212, $P1218 + unless_1213_end: + $P1219 = $P1211($P1212) + store_lex "$octlit", $P1219 +.annotate 'line', 332 + find_lex $P1220, "$/" + find_lex $P1223, "$/" unless_null $P1223, vivify_292 - new $P1223, "Undef" + $P1223 = root_new ['parrot';'Hash'] vivify_292: - set $P1217, $P1223 - unless_1218_end: - $P1224 = $P1216($P1217) - store_lex "$hexlit", $P1224 -.annotate 'line', 326 - find_lex $P1225, "$/" - find_lex $P1228, "$/" - unless_null $P1228, vivify_293 - $P1228 = root_new ['parrot';'Hash'] + set $P1224, $P1223["sym"] + unless_null $P1224, vivify_293 + new $P1224, "Undef" vivify_293: - set $P1229, $P1228["sym"] - unless_null $P1229, vivify_294 - new $P1229, "Undef" - vivify_294: - set $S1230, $P1229 - iseq $I1231, $S1230, "X" - if $I1231, if_1227 + set $S1225, $P1224 + iseq $I1226, $S1225, "O" + if $I1226, if_1222 +.annotate 'line', 335 + get_hll_global $P1231, ["PAST"], "Regex" + find_lex $P1232, "$octlit" + find_lex $P1233, "$/" + $P1234 = $P1231."new"($P1232, "literal" :named("pasttype"), $P1233 :named("node")) + set $P1221, $P1234 +.annotate 'line', 332 + goto if_1222_end + if_1222: +.annotate 'line', 333 + get_hll_global $P1227, ["PAST"], "Regex" + find_lex $P1228, "$octlit" + find_lex $P1229, "$/" + $P1230 = $P1227."new"($P1228, "enumcharlist" :named("pasttype"), 1 :named("negate"), $P1229 :named("node")) + set $P1221, $P1230 + if_1222_end: + $P1235 = $P1220."!make"($P1221) .annotate 'line', 329 - get_hll_global $P1236, ["PAST"], "Regex" - find_lex $P1237, "$hexlit" - find_lex $P1238, "$/" - $P1239 = $P1236."new"($P1237, "literal" :named("pasttype"), $P1238 :named("node")) - set $P1226, $P1239 -.annotate 'line', 326 - goto if_1227_end - if_1227: -.annotate 'line', 327 - get_hll_global $P1232, ["PAST"], "Regex" - find_lex $P1233, "$hexlit" - find_lex $P1234, "$/" - $P1235 = $P1232."new"($P1233, "enumcharlist" :named("pasttype"), 1 :named("negate"), $P1234 :named("node")) - set $P1226, $P1235 - if_1227_end: - $P1240 = $P1225."!make"($P1226) -.annotate 'line', 323 - .return ($P1240) - control_1212: + .return ($P1235) + control_1207: .local pmc exception .get_results (exception) - getattribute $P1241, exception, "payload" - .return ($P1241) + getattribute $P1236, exception, "payload" + .return ($P1236) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "backslash:sym" :subid("74_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1245 -.annotate 'line', 332 - new $P1244, 'ExceptionHandler' - set_addr $P1244, control_1243 - $P1244."handle_types"(57) - push_eh $P1244 +.sub "backslash:sym" :subid("74_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1240 +.annotate 'line', 338 + new $P1239, 'ExceptionHandler' + set_addr $P1239, control_1238 + $P1239."handle_types"(57) + push_eh $P1239 .lex "self", self - .lex "$/", param_1245 -.annotate 'line', 333 - find_lex $P1246, "$/" - get_hll_global $P1247, ["PAST"], "Regex" - find_lex $P1248, "$/" - unless_null $P1248, vivify_295 - $P1248 = root_new ['parrot';'Hash'] + .lex "$/", param_1240 +.annotate 'line', 339 + new $P1241, "Undef" + .lex "$hexlit", $P1241 +.annotate 'line', 340 + get_hll_global $P1242, ["HLL";"Actions"], "ints_to_string" + find_lex $P1245, "$/" + unless_null $P1245, vivify_294 + $P1245 = root_new ['parrot';'Hash'] + vivify_294: + set $P1246, $P1245["hexint"] + unless_null $P1246, vivify_295 + new $P1246, "Undef" vivify_295: - set $P1249, $P1248["charspec"] - unless_null $P1249, vivify_296 - new $P1249, "Undef" + unless $P1246, unless_1244 + set $P1243, $P1246 + goto unless_1244_end + unless_1244: + find_lex $P1247, "$/" + unless_null $P1247, vivify_296 + $P1247 = root_new ['parrot';'Hash'] vivify_296: - $P1250 = $P1249."ast"() + set $P1248, $P1247["hexints"] + unless_null $P1248, vivify_297 + $P1248 = root_new ['parrot';'Hash'] + vivify_297: + set $P1249, $P1248["hexint"] + unless_null $P1249, vivify_298 + new $P1249, "Undef" + vivify_298: + set $P1243, $P1249 + unless_1244_end: + $P1250 = $P1242($P1243) + store_lex "$hexlit", $P1250 +.annotate 'line', 341 find_lex $P1251, "$/" - $P1252 = $P1247."new"($P1250, "literal" :named("pasttype"), $P1251 :named("node")) - $P1253 = $P1246."!make"($P1252) -.annotate 'line', 332 - .return ($P1253) - control_1243: + find_lex $P1254, "$/" + unless_null $P1254, vivify_299 + $P1254 = root_new ['parrot';'Hash'] + vivify_299: + set $P1255, $P1254["sym"] + unless_null $P1255, vivify_300 + new $P1255, "Undef" + vivify_300: + set $S1256, $P1255 + iseq $I1257, $S1256, "X" + if $I1257, if_1253 +.annotate 'line', 344 + get_hll_global $P1262, ["PAST"], "Regex" + find_lex $P1263, "$hexlit" + find_lex $P1264, "$/" + $P1265 = $P1262."new"($P1263, "literal" :named("pasttype"), $P1264 :named("node")) + set $P1252, $P1265 +.annotate 'line', 341 + goto if_1253_end + if_1253: +.annotate 'line', 342 + get_hll_global $P1258, ["PAST"], "Regex" + find_lex $P1259, "$hexlit" + find_lex $P1260, "$/" + $P1261 = $P1258."new"($P1259, "enumcharlist" :named("pasttype"), 1 :named("negate"), $P1260 :named("node")) + set $P1252, $P1261 + if_1253_end: + $P1266 = $P1251."!make"($P1252) +.annotate 'line', 338 + .return ($P1266) + control_1238: .local pmc exception .get_results (exception) - getattribute $P1254, exception, "payload" - .return ($P1254) + getattribute $P1267, exception, "payload" + .return ($P1267) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "backslash:sym" :subid("75_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1258 -.annotate 'line', 336 - new $P1257, 'ExceptionHandler' - set_addr $P1257, control_1256 - $P1257."handle_types"(57) - push_eh $P1257 +.sub "backslash:sym" :subid("75_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1271 +.annotate 'line', 347 + new $P1270, 'ExceptionHandler' + set_addr $P1270, control_1269 + $P1270."handle_types"(57) + push_eh $P1270 .lex "self", self - .lex "$/", param_1258 -.annotate 'line', 337 - new $P1259, "Undef" - .lex "$past", $P1259 - get_hll_global $P1260, ["PAST"], "Regex" - find_lex $P1261, "$/" - set $S1262, $P1261 - find_lex $P1263, "$/" - $P1264 = $P1260."new"($S1262, "literal" :named("pasttype"), $P1263 :named("node")) - store_lex "$past", $P1264 -.annotate 'line', 338 - find_lex $P1265, "$/" - find_lex $P1266, "$past" - $P1267 = $P1265."!make"($P1266) -.annotate 'line', 336 - .return ($P1267) - control_1256: + .lex "$/", param_1271 +.annotate 'line', 348 + find_lex $P1272, "$/" + get_hll_global $P1273, ["PAST"], "Regex" + find_lex $P1274, "$/" + unless_null $P1274, vivify_301 + $P1274 = root_new ['parrot';'Hash'] + vivify_301: + set $P1275, $P1274["charspec"] + unless_null $P1275, vivify_302 + new $P1275, "Undef" + vivify_302: + $P1276 = $P1275."ast"() + find_lex $P1277, "$/" + $P1278 = $P1273."new"($P1276, "literal" :named("pasttype"), $P1277 :named("node")) + $P1279 = $P1272."!make"($P1278) +.annotate 'line', 347 + .return ($P1279) + control_1269: .local pmc exception .get_results (exception) - getattribute $P1268, exception, "payload" - .return ($P1268) + getattribute $P1280, exception, "payload" + .return ($P1280) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "assertion:sym" :subid("76_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1272 -.annotate 'line', 342 - new $P1271, 'ExceptionHandler' - set_addr $P1271, control_1270 - $P1271."handle_types"(57) - push_eh $P1271 +.sub "backslash:sym" :subid("76_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1284 +.annotate 'line', 351 + new $P1283, 'ExceptionHandler' + set_addr $P1283, control_1282 + $P1283."handle_types"(57) + push_eh $P1283 .lex "self", self - .lex "$/", param_1272 -.annotate 'line', 343 - new $P1273, "Undef" - .lex "$past", $P1273 -.annotate 'line', 342 - find_lex $P1274, "$past" -.annotate 'line', 344 - find_lex $P1276, "$/" - unless_null $P1276, vivify_297 - $P1276 = root_new ['parrot';'Hash'] - vivify_297: - set $P1277, $P1276["assertion"] - unless_null $P1277, vivify_298 - new $P1277, "Undef" - vivify_298: - if $P1277, if_1275 -.annotate 'line', 348 - new $P1282, "Integer" - assign $P1282, 0 - store_lex "$past", $P1282 - goto if_1275_end - if_1275: -.annotate 'line', 345 - find_lex $P1278, "$/" - unless_null $P1278, vivify_299 - $P1278 = root_new ['parrot';'Hash'] - vivify_299: - set $P1279, $P1278["assertion"] - unless_null $P1279, vivify_300 - new $P1279, "Undef" - vivify_300: - $P1280 = $P1279."ast"() - store_lex "$past", $P1280 -.annotate 'line', 346 - find_lex $P1281, "$past" - $P1281."subtype"("zerowidth") - if_1275_end: -.annotate 'line', 349 - find_lex $P1283, "$/" - find_lex $P1284, "$past" - $P1285 = $P1283."!make"($P1284) -.annotate 'line', 342 - .return ($P1285) - control_1270: + .lex "$/", param_1284 +.annotate 'line', 352 + new $P1285, "Undef" + .lex "$past", $P1285 + get_hll_global $P1286, ["PAST"], "Regex" + find_lex $P1287, "$/" + set $S1288, $P1287 + find_lex $P1289, "$/" + $P1290 = $P1286."new"($S1288, "literal" :named("pasttype"), $P1289 :named("node")) + store_lex "$past", $P1290 +.annotate 'line', 353 + find_lex $P1291, "$/" + find_lex $P1292, "$past" + $P1293 = $P1291."!make"($P1292) +.annotate 'line', 351 + .return ($P1293) + control_1282: .local pmc exception .get_results (exception) - getattribute $P1286, exception, "payload" - .return ($P1286) + getattribute $P1294, exception, "payload" + .return ($P1294) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "assertion:sym" :subid("77_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1290 -.annotate 'line', 352 - new $P1289, 'ExceptionHandler' - set_addr $P1289, control_1288 - $P1289."handle_types"(57) - push_eh $P1289 +.sub "assertion:sym" :subid("77_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1298 +.annotate 'line', 357 + new $P1297, 'ExceptionHandler' + set_addr $P1297, control_1296 + $P1297."handle_types"(57) + push_eh $P1297 .lex "self", self - .lex "$/", param_1290 -.annotate 'line', 353 - new $P1291, "Undef" - .lex "$past", $P1291 -.annotate 'line', 352 - find_lex $P1292, "$past" -.annotate 'line', 354 - find_lex $P1294, "$/" - unless_null $P1294, vivify_301 - $P1294 = root_new ['parrot';'Hash'] - vivify_301: - set $P1295, $P1294["assertion"] - unless_null $P1295, vivify_302 - new $P1295, "Undef" - vivify_302: - if $P1295, if_1293 -.annotate 'line', 360 - get_hll_global $P1304, ["PAST"], "Regex" - find_lex $P1305, "$/" - $P1306 = $P1304."new"("anchor" :named("pasttype"), "fail" :named("subtype"), $P1305 :named("node")) - store_lex "$past", $P1306 + .lex "$/", param_1298 +.annotate 'line', 358 + new $P1299, "Undef" + .lex "$past", $P1299 +.annotate 'line', 357 + find_lex $P1300, "$past" .annotate 'line', 359 - goto if_1293_end - if_1293: -.annotate 'line', 355 - find_lex $P1296, "$/" - unless_null $P1296, vivify_303 - $P1296 = root_new ['parrot';'Hash'] + find_lex $P1302, "$/" + unless_null $P1302, vivify_303 + $P1302 = root_new ['parrot';'Hash'] vivify_303: - set $P1297, $P1296["assertion"] - unless_null $P1297, vivify_304 - new $P1297, "Undef" + set $P1303, $P1302["assertion"] + unless_null $P1303, vivify_304 + new $P1303, "Undef" vivify_304: - $P1298 = $P1297."ast"() - store_lex "$past", $P1298 -.annotate 'line', 356 - find_lex $P1299, "$past" - find_lex $P1300, "$past" - $P1301 = $P1300."negate"() - isfalse $I1302, $P1301 - $P1299."negate"($I1302) + if $P1303, if_1301 +.annotate 'line', 363 + new $P1308, "Integer" + assign $P1308, 0 + store_lex "$past", $P1308 + goto if_1301_end + if_1301: +.annotate 'line', 360 + find_lex $P1304, "$/" + unless_null $P1304, vivify_305 + $P1304 = root_new ['parrot';'Hash'] + vivify_305: + set $P1305, $P1304["assertion"] + unless_null $P1305, vivify_306 + new $P1305, "Undef" + vivify_306: + $P1306 = $P1305."ast"() + store_lex "$past", $P1306 +.annotate 'line', 361 + find_lex $P1307, "$past" + $P1307."subtype"("zerowidth") + if_1301_end: +.annotate 'line', 364 + find_lex $P1309, "$/" + find_lex $P1310, "$past" + $P1311 = $P1309."!make"($P1310) .annotate 'line', 357 - find_lex $P1303, "$past" - $P1303."subtype"("zerowidth") - if_1293_end: -.annotate 'line', 362 - find_lex $P1307, "$/" - find_lex $P1308, "$past" - $P1309 = $P1307."!make"($P1308) -.annotate 'line', 352 - .return ($P1309) - control_1288: + .return ($P1311) + control_1296: .local pmc exception .get_results (exception) - getattribute $P1310, exception, "payload" - .return ($P1310) + getattribute $P1312, exception, "payload" + .return ($P1312) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "assertion:sym" :subid("78_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1314 -.annotate 'line', 365 - new $P1313, 'ExceptionHandler' - set_addr $P1313, control_1312 - $P1313."handle_types"(57) - push_eh $P1313 +.sub "assertion:sym" :subid("78_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1316 +.annotate 'line', 367 + new $P1315, 'ExceptionHandler' + set_addr $P1315, control_1314 + $P1315."handle_types"(57) + push_eh $P1315 .lex "self", self - .lex "$/", param_1314 -.annotate 'line', 366 - new $P1315, "Undef" - .lex "$past", $P1315 - find_lex $P1316, "$/" - unless_null $P1316, vivify_305 - $P1316 = root_new ['parrot';'Hash'] - vivify_305: - set $P1317, $P1316["assertion"] - unless_null $P1317, vivify_306 + .lex "$/", param_1316 +.annotate 'line', 368 new $P1317, "Undef" - vivify_306: - $P1318 = $P1317."ast"() - store_lex "$past", $P1318 + .lex "$past", $P1317 .annotate 'line', 367 - find_lex $P1319, "$past" - $P1319."subtype"("method") -.annotate 'line', 368 - find_lex $P1320, "$past" - $P1320."name"("") + find_lex $P1318, "$past" .annotate 'line', 369 - find_lex $P1321, "$/" - find_lex $P1322, "$past" - $P1323 = $P1321."!make"($P1322) -.annotate 'line', 365 - .return ($P1323) - control_1312: + find_lex $P1320, "$/" + unless_null $P1320, vivify_307 + $P1320 = root_new ['parrot';'Hash'] + vivify_307: + set $P1321, $P1320["assertion"] + unless_null $P1321, vivify_308 + new $P1321, "Undef" + vivify_308: + if $P1321, if_1319 +.annotate 'line', 375 + get_hll_global $P1330, ["PAST"], "Regex" + find_lex $P1331, "$/" + $P1332 = $P1330."new"("anchor" :named("pasttype"), "fail" :named("subtype"), $P1331 :named("node")) + store_lex "$past", $P1332 +.annotate 'line', 374 + goto if_1319_end + if_1319: +.annotate 'line', 370 + find_lex $P1322, "$/" + unless_null $P1322, vivify_309 + $P1322 = root_new ['parrot';'Hash'] + vivify_309: + set $P1323, $P1322["assertion"] + unless_null $P1323, vivify_310 + new $P1323, "Undef" + vivify_310: + $P1324 = $P1323."ast"() + store_lex "$past", $P1324 +.annotate 'line', 371 + find_lex $P1325, "$past" + find_lex $P1326, "$past" + $P1327 = $P1326."negate"() + isfalse $I1328, $P1327 + $P1325."negate"($I1328) +.annotate 'line', 372 + find_lex $P1329, "$past" + $P1329."subtype"("zerowidth") + if_1319_end: +.annotate 'line', 377 + find_lex $P1333, "$/" + find_lex $P1334, "$past" + $P1335 = $P1333."!make"($P1334) +.annotate 'line', 367 + .return ($P1335) + control_1314: .local pmc exception .get_results (exception) - getattribute $P1324, exception, "payload" - .return ($P1324) + getattribute $P1336, exception, "payload" + .return ($P1336) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "assertion:sym" :subid("79_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1328 -.annotate 'line', 372 - .const 'Sub' $P1386 = "81_1275511714.5903" - capture_lex $P1386 - .const 'Sub' $P1350 = "80_1275511714.5903" - capture_lex $P1350 - new $P1327, 'ExceptionHandler' - set_addr $P1327, control_1326 - $P1327."handle_types"(57) - push_eh $P1327 +.sub "assertion:sym" :subid("79_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1340 +.annotate 'line', 380 + new $P1339, 'ExceptionHandler' + set_addr $P1339, control_1338 + $P1339."handle_types"(57) + push_eh $P1339 .lex "self", self - .lex "$/", param_1328 -.annotate 'line', 373 - new $P1329, "Undef" - .lex "$name", $P1329 -.annotate 'line', 374 - new $P1330, "Undef" - .lex "$past", $P1330 -.annotate 'line', 373 - find_lex $P1331, "$/" - unless_null $P1331, vivify_307 - $P1331 = root_new ['parrot';'Hash'] - vivify_307: - set $P1332, $P1331["longname"] - unless_null $P1332, vivify_308 - new $P1332, "Undef" - vivify_308: - set $S1333, $P1332 - new $P1334, 'String' - set $P1334, $S1333 - store_lex "$name", $P1334 - find_lex $P1335, "$past" -.annotate 'line', 375 - find_lex $P1337, "$/" - unless_null $P1337, vivify_309 - $P1337 = root_new ['parrot';'Hash'] - vivify_309: - set $P1338, $P1337["assertion"] - unless_null $P1338, vivify_310 - new $P1338, "Undef" - vivify_310: - if $P1338, if_1336 -.annotate 'line', 379 - find_lex $P1346, "$name" - set $S1347, $P1346 - iseq $I1348, $S1347, "sym" - if $I1348, if_1345 -.annotate 'line', 395 - get_hll_global $P1360, ["PAST"], "Regex" - find_lex $P1361, "$name" - find_lex $P1362, "$name" - find_lex $P1363, "$/" - $P1364 = $P1360."new"($P1361, $P1362 :named("name"), "subrule" :named("pasttype"), "capture" :named("subtype"), $P1363 :named("node")) - store_lex "$past", $P1364 -.annotate 'line', 397 - find_lex $P1366, "$/" - unless_null $P1366, vivify_311 - $P1366 = root_new ['parrot';'Hash'] + .lex "$/", param_1340 +.annotate 'line', 381 + new $P1341, "Undef" + .lex "$past", $P1341 + find_lex $P1342, "$/" + unless_null $P1342, vivify_311 + $P1342 = root_new ['parrot';'Hash'] vivify_311: - set $P1367, $P1366["nibbler"] - unless_null $P1367, vivify_312 - new $P1367, "Undef" + set $P1343, $P1342["assertion"] + unless_null $P1343, vivify_312 + new $P1343, "Undef" vivify_312: - if $P1367, if_1365 -.annotate 'line', 400 - find_lex $P1375, "$/" - unless_null $P1375, vivify_313 - $P1375 = root_new ['parrot';'Hash'] + $P1344 = $P1343."ast"() + store_lex "$past", $P1344 +.annotate 'line', 382 + find_lex $P1345, "$past" + $P1345."subtype"("method") +.annotate 'line', 383 + find_lex $P1346, "$past" + $P1346."name"("") +.annotate 'line', 384 + find_lex $P1347, "$/" + find_lex $P1348, "$past" + $P1349 = $P1347."!make"($P1348) +.annotate 'line', 380 + .return ($P1349) + control_1338: + .local pmc exception + .get_results (exception) + getattribute $P1350, exception, "payload" + .return ($P1350) +.end + + +.namespace ["Regex";"P6Regex";"Actions"] +.sub "assertion:sym" :subid("80_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1354 +.annotate 'line', 387 + .const 'Sub' $P1412 = "82_1275600002.0917" + capture_lex $P1412 + .const 'Sub' $P1376 = "81_1275600002.0917" + capture_lex $P1376 + new $P1353, 'ExceptionHandler' + set_addr $P1353, control_1352 + $P1353."handle_types"(57) + push_eh $P1353 + .lex "self", self + .lex "$/", param_1354 +.annotate 'line', 388 + new $P1355, "Undef" + .lex "$name", $P1355 +.annotate 'line', 389 + new $P1356, "Undef" + .lex "$past", $P1356 +.annotate 'line', 388 + find_lex $P1357, "$/" + unless_null $P1357, vivify_313 + $P1357 = root_new ['parrot';'Hash'] vivify_313: - set $P1376, $P1375["arglist"] - unless_null $P1376, vivify_314 - new $P1376, "Undef" + set $P1358, $P1357["longname"] + unless_null $P1358, vivify_314 + new $P1358, "Undef" vivify_314: - unless $P1376, if_1374_end -.annotate 'line', 401 - find_lex $P1378, "$/" - unless_null $P1378, vivify_315 - $P1378 = root_new ['parrot';'Hash'] + set $S1359, $P1358 + new $P1360, 'String' + set $P1360, $S1359 + store_lex "$name", $P1360 + find_lex $P1361, "$past" +.annotate 'line', 390 + find_lex $P1363, "$/" + unless_null $P1363, vivify_315 + $P1363 = root_new ['parrot';'Hash'] vivify_315: - set $P1379, $P1378["arglist"] - unless_null $P1379, vivify_316 - $P1379 = root_new ['parrot';'ResizablePMCArray'] + set $P1364, $P1363["assertion"] + unless_null $P1364, vivify_316 + new $P1364, "Undef" vivify_316: - set $P1380, $P1379[0] - unless_null $P1380, vivify_317 - new $P1380, "Undef" + if $P1364, if_1362 +.annotate 'line', 394 + find_lex $P1372, "$name" + set $S1373, $P1372 + iseq $I1374, $S1373, "sym" + if $I1374, if_1371 +.annotate 'line', 410 + get_hll_global $P1386, ["PAST"], "Regex" + find_lex $P1387, "$name" + find_lex $P1388, "$name" + find_lex $P1389, "$/" + $P1390 = $P1386."new"($P1387, $P1388 :named("name"), "subrule" :named("pasttype"), "capture" :named("subtype"), $P1389 :named("node")) + store_lex "$past", $P1390 +.annotate 'line', 412 + find_lex $P1392, "$/" + unless_null $P1392, vivify_317 + $P1392 = root_new ['parrot';'Hash'] vivify_317: - $P1381 = $P1380."ast"() - $P1382 = $P1381."list"() - defined $I1383, $P1382 - unless $I1383, for_undef_318 - iter $P1377, $P1382 - new $P1392, 'ExceptionHandler' - set_addr $P1392, loop1391_handler - $P1392."handle_types"(64, 66, 65) - push_eh $P1392 - loop1391_test: - unless $P1377, loop1391_done - shift $P1384, $P1377 - loop1391_redo: - .const 'Sub' $P1386 = "81_1275511714.5903" - capture_lex $P1386 - $P1386($P1384) - loop1391_next: - goto loop1391_test - loop1391_handler: - .local pmc exception - .get_results (exception) - getattribute $P1393, exception, 'type' - eq $P1393, 64, loop1391_next - eq $P1393, 66, loop1391_redo - loop1391_done: - pop_eh - for_undef_318: - if_1374_end: -.annotate 'line', 400 - goto if_1365_end - if_1365: -.annotate 'line', 398 - find_lex $P1368, "$past" - find_lex $P1369, "$/" - unless_null $P1369, vivify_319 - $P1369 = root_new ['parrot';'Hash'] + set $P1393, $P1392["nibbler"] + unless_null $P1393, vivify_318 + new $P1393, "Undef" + vivify_318: + if $P1393, if_1391 +.annotate 'line', 415 + find_lex $P1401, "$/" + unless_null $P1401, vivify_319 + $P1401 = root_new ['parrot';'Hash'] vivify_319: - set $P1370, $P1369["nibbler"] - unless_null $P1370, vivify_320 - $P1370 = root_new ['parrot';'ResizablePMCArray'] + set $P1402, $P1401["arglist"] + unless_null $P1402, vivify_320 + new $P1402, "Undef" vivify_320: - set $P1371, $P1370[0] - unless_null $P1371, vivify_321 - new $P1371, "Undef" + unless $P1402, if_1400_end +.annotate 'line', 416 + find_lex $P1404, "$/" + unless_null $P1404, vivify_321 + $P1404 = root_new ['parrot';'Hash'] vivify_321: - $P1372 = $P1371."ast"() - $P1373 = "buildsub"($P1372) - $P1368."push"($P1373) - if_1365_end: -.annotate 'line', 394 - goto if_1345_end - if_1345: -.annotate 'line', 379 - .const 'Sub' $P1350 = "80_1275511714.5903" - capture_lex $P1350 - $P1350() - if_1345_end: - goto if_1336_end - if_1336: -.annotate 'line', 376 - find_lex $P1339, "$/" - unless_null $P1339, vivify_322 - $P1339 = root_new ['parrot';'Hash'] + set $P1405, $P1404["arglist"] + unless_null $P1405, vivify_322 + $P1405 = root_new ['parrot';'ResizablePMCArray'] vivify_322: - set $P1340, $P1339["assertion"] - unless_null $P1340, vivify_323 - $P1340 = root_new ['parrot';'ResizablePMCArray'] + set $P1406, $P1405[0] + unless_null $P1406, vivify_323 + new $P1406, "Undef" vivify_323: - set $P1341, $P1340[0] - unless_null $P1341, vivify_324 - new $P1341, "Undef" - vivify_324: - $P1342 = $P1341."ast"() - store_lex "$past", $P1342 -.annotate 'line', 377 - find_lex $P1343, "$past" - find_lex $P1344, "$name" - "subrule_alias"($P1343, $P1344) - if_1336_end: -.annotate 'line', 404 - find_lex $P1394, "$/" - find_lex $P1395, "$past" - $P1396 = $P1394."!make"($P1395) -.annotate 'line', 372 - .return ($P1396) - control_1326: + $P1407 = $P1406."ast"() + $P1408 = $P1407."list"() + defined $I1409, $P1408 + unless $I1409, for_undef_324 + iter $P1403, $P1408 + new $P1418, 'ExceptionHandler' + set_addr $P1418, loop1417_handler + $P1418."handle_types"(64, 66, 65) + push_eh $P1418 + loop1417_test: + unless $P1403, loop1417_done + shift $P1410, $P1403 + loop1417_redo: + .const 'Sub' $P1412 = "82_1275600002.0917" + capture_lex $P1412 + $P1412($P1410) + loop1417_next: + goto loop1417_test + loop1417_handler: .local pmc exception .get_results (exception) - getattribute $P1397, exception, "payload" - .return ($P1397) + getattribute $P1419, exception, 'type' + eq $P1419, 64, loop1417_next + eq $P1419, 66, loop1417_redo + loop1417_done: + pop_eh + for_undef_324: + if_1400_end: +.annotate 'line', 415 + goto if_1391_end + if_1391: +.annotate 'line', 413 + find_lex $P1394, "$past" + find_lex $P1395, "$/" + unless_null $P1395, vivify_325 + $P1395 = root_new ['parrot';'Hash'] + vivify_325: + set $P1396, $P1395["nibbler"] + unless_null $P1396, vivify_326 + $P1396 = root_new ['parrot';'ResizablePMCArray'] + vivify_326: + set $P1397, $P1396[0] + unless_null $P1397, vivify_327 + new $P1397, "Undef" + vivify_327: + $P1398 = $P1397."ast"() + $P1399 = "buildsub"($P1398) + $P1394."push"($P1399) + if_1391_end: +.annotate 'line', 409 + goto if_1371_end + if_1371: +.annotate 'line', 394 + .const 'Sub' $P1376 = "81_1275600002.0917" + capture_lex $P1376 + $P1376() + if_1371_end: + goto if_1362_end + if_1362: +.annotate 'line', 391 + find_lex $P1365, "$/" + unless_null $P1365, vivify_328 + $P1365 = root_new ['parrot';'Hash'] + vivify_328: + set $P1366, $P1365["assertion"] + unless_null $P1366, vivify_329 + $P1366 = root_new ['parrot';'ResizablePMCArray'] + vivify_329: + set $P1367, $P1366[0] + unless_null $P1367, vivify_330 + new $P1367, "Undef" + vivify_330: + $P1368 = $P1367."ast"() + store_lex "$past", $P1368 +.annotate 'line', 392 + find_lex $P1369, "$past" + find_lex $P1370, "$name" + "subrule_alias"($P1369, $P1370) + if_1362_end: +.annotate 'line', 419 + find_lex $P1420, "$/" + find_lex $P1421, "$past" + $P1422 = $P1420."!make"($P1421) +.annotate 'line', 387 + .return ($P1422) + control_1352: + .local pmc exception + .get_results (exception) + getattribute $P1423, exception, "payload" + .return ($P1423) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block1385" :anon :subid("81_1275511714.5903") :outer("79_1275511714.5903") - .param pmc param_1387 -.annotate 'line', 401 - .lex "$_", param_1387 - find_lex $P1388, "$past" - find_lex $P1389, "$_" - $P1390 = $P1388."push"($P1389) - .return ($P1390) +.sub "_block1411" :anon :subid("82_1275600002.0917") :outer("80_1275600002.0917") + .param pmc param_1413 +.annotate 'line', 416 + .lex "$_", param_1413 + find_lex $P1414, "$past" + find_lex $P1415, "$_" + $P1416 = $P1414."push"($P1415) + .return ($P1416) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block1349" :anon :subid("80_1275511714.5903") :outer("79_1275511714.5903") -.annotate 'line', 380 - new $P1351, "Undef" - .lex "$regexsym", $P1351 +.sub "_block1375" :anon :subid("81_1275600002.0917") :outer("80_1275600002.0917") +.annotate 'line', 395 + new $P1377, "Undef" + .lex "$regexsym", $P1377 $P0 = get_global '$REGEXNAME' $S0 = $P0 @@ -11398,388 +11487,388 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes add $I0, 5 $S0 = substr $S0, $I0 $S0 = chopn $S0, 1 - $P1352 = box $S0 + $P1378 = box $S0 - store_lex "$regexsym", $P1352 -.annotate 'line', 389 - get_hll_global $P1353, ["PAST"], "Regex" -.annotate 'line', 390 - get_hll_global $P1354, ["PAST"], "Regex" - find_lex $P1355, "$regexsym" - $P1356 = $P1354."new"($P1355, "literal" :named("pasttype")) - find_lex $P1357, "$name" - find_lex $P1358, "$/" - $P1359 = $P1353."new"($P1356, $P1357 :named("name"), "subcapture" :named("pasttype"), $P1358 :named("node")) -.annotate 'line', 389 - store_lex "$past", $P1359 -.annotate 'line', 379 - .return ($P1359) -.end - - -.namespace ["Regex";"P6Regex";"Actions"] -.sub "assertion:sym<[>" :subid("82_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1401 -.annotate 'line', 407 - .const 'Sub' $P1436 = "83_1275511714.5903" - capture_lex $P1436 - new $P1400, 'ExceptionHandler' - set_addr $P1400, control_1399 - $P1400."handle_types"(57) - push_eh $P1400 - .lex "self", self - .lex "$/", param_1401 -.annotate 'line', 408 - new $P1402, "Undef" - .lex "$clist", $P1402 -.annotate 'line', 409 - new $P1403, "Undef" - .lex "$past", $P1403 -.annotate 'line', 418 - new $P1404, "Undef" - .lex "$i", $P1404 -.annotate 'line', 419 - new $P1405, "Undef" - .lex "$n", $P1405 -.annotate 'line', 408 - find_lex $P1406, "$/" - unless_null $P1406, vivify_325 - $P1406 = root_new ['parrot';'Hash'] - vivify_325: - set $P1407, $P1406["cclass_elem"] - unless_null $P1407, vivify_326 - new $P1407, "Undef" - vivify_326: - store_lex "$clist", $P1407 -.annotate 'line', 409 - find_lex $P1408, "$clist" - unless_null $P1408, vivify_327 - $P1408 = root_new ['parrot';'ResizablePMCArray'] - vivify_327: - set $P1409, $P1408[0] - unless_null $P1409, vivify_328 - new $P1409, "Undef" - vivify_328: - $P1410 = $P1409."ast"() - store_lex "$past", $P1410 -.annotate 'line', 410 - find_lex $P1414, "$past" - $P1415 = $P1414."negate"() - if $P1415, if_1413 - set $P1412, $P1415 - goto if_1413_end - if_1413: - find_lex $P1416, "$past" - $S1417 = $P1416."pasttype"() - iseq $I1418, $S1417, "subrule" - new $P1412, 'Integer' - set $P1412, $I1418 - if_1413_end: - unless $P1412, if_1411_end -.annotate 'line', 411 - find_lex $P1419, "$past" - $P1419."subtype"("zerowidth") -.annotate 'line', 412 - get_hll_global $P1420, ["PAST"], "Regex" - find_lex $P1421, "$past" -.annotate 'line', 414 - get_hll_global $P1422, ["PAST"], "Regex" - $P1423 = $P1422."new"("charclass" :named("pasttype"), "." :named("subtype")) - find_lex $P1424, "$/" - $P1425 = $P1420."new"($P1421, $P1423, $P1424 :named("node")) -.annotate 'line', 412 - store_lex "$past", $P1425 - if_1411_end: -.annotate 'line', 418 - new $P1426, "Integer" - assign $P1426, 1 - store_lex "$i", $P1426 -.annotate 'line', 419 - find_lex $P1427, "$clist" - set $N1428, $P1427 - new $P1429, 'Float' - set $P1429, $N1428 - store_lex "$n", $P1429 -.annotate 'line', 420 - new $P1460, 'ExceptionHandler' - set_addr $P1460, loop1459_handler - $P1460."handle_types"(64, 66, 65) - push_eh $P1460 - loop1459_test: - find_lex $P1430, "$i" - set $N1431, $P1430 - find_lex $P1432, "$n" - set $N1433, $P1432 - islt $I1434, $N1431, $N1433 - unless $I1434, loop1459_done - loop1459_redo: - .const 'Sub' $P1436 = "83_1275511714.5903" - capture_lex $P1436 - $P1436() - loop1459_next: - goto loop1459_test - loop1459_handler: - .local pmc exception - .get_results (exception) - getattribute $P1461, exception, 'type' - eq $P1461, 64, loop1459_next - eq $P1461, 66, loop1459_redo - loop1459_done: - pop_eh -.annotate 'line', 431 - find_lex $P1462, "$/" - find_lex $P1463, "$past" - $P1464 = $P1462."!make"($P1463) -.annotate 'line', 407 - .return ($P1464) - control_1399: - .local pmc exception - .get_results (exception) - getattribute $P1465, exception, "payload" - .return ($P1465) + store_lex "$regexsym", $P1378 +.annotate 'line', 404 + get_hll_global $P1379, ["PAST"], "Regex" +.annotate 'line', 405 + get_hll_global $P1380, ["PAST"], "Regex" + find_lex $P1381, "$regexsym" + $P1382 = $P1380."new"($P1381, "literal" :named("pasttype")) + find_lex $P1383, "$name" + find_lex $P1384, "$/" + $P1385 = $P1379."new"($P1382, $P1383 :named("name"), "subcapture" :named("pasttype"), $P1384 :named("node")) +.annotate 'line', 404 + store_lex "$past", $P1385 +.annotate 'line', 394 + .return ($P1385) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block1435" :anon :subid("83_1275511714.5903") :outer("82_1275511714.5903") -.annotate 'line', 421 - new $P1437, "Undef" - .lex "$ast", $P1437 - find_lex $P1438, "$i" - set $I1439, $P1438 - find_lex $P1440, "$clist" - unless_null $P1440, vivify_329 - $P1440 = root_new ['parrot';'ResizablePMCArray'] - vivify_329: - set $P1441, $P1440[$I1439] - unless_null $P1441, vivify_330 - new $P1441, "Undef" - vivify_330: - $P1442 = $P1441."ast"() - store_lex "$ast", $P1442 +.sub "assertion:sym<[>" :subid("83_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1427 .annotate 'line', 422 - find_lex $P1444, "$ast" - $P1445 = $P1444."negate"() - if $P1445, if_1443 -.annotate 'line', 427 - get_hll_global $P1452, ["PAST"], "Regex" - find_lex $P1453, "$past" - find_lex $P1454, "$ast" - find_lex $P1455, "$/" - $P1456 = $P1452."new"($P1453, $P1454, "alt" :named("pasttype"), $P1455 :named("node")) - store_lex "$past", $P1456 -.annotate 'line', 426 - goto if_1443_end - if_1443: + .const 'Sub' $P1462 = "84_1275600002.0917" + capture_lex $P1462 + new $P1426, 'ExceptionHandler' + set_addr $P1426, control_1425 + $P1426."handle_types"(57) + push_eh $P1426 + .lex "self", self + .lex "$/", param_1427 .annotate 'line', 423 - find_lex $P1446, "$ast" - $P1446."subtype"("zerowidth") + new $P1428, "Undef" + .lex "$clist", $P1428 .annotate 'line', 424 - get_hll_global $P1447, ["PAST"], "Regex" - find_lex $P1448, "$ast" - find_lex $P1449, "$past" - find_lex $P1450, "$/" - $P1451 = $P1447."new"($P1448, $P1449, "concat" :named("pasttype"), $P1450 :named("node")) - store_lex "$past", $P1451 - if_1443_end: -.annotate 'line', 429 - find_lex $P1457, "$i" - add $P1458, $P1457, 1 - store_lex "$i", $P1458 -.annotate 'line', 420 - .return ($P1458) -.end - - -.namespace ["Regex";"P6Regex";"Actions"] -.sub "cclass_elem" :subid("84_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1469 + new $P1429, "Undef" + .lex "$past", $P1429 +.annotate 'line', 433 + new $P1430, "Undef" + .lex "$i", $P1430 .annotate 'line', 434 - .const 'Sub' $P1494 = "86_1275511714.5903" - capture_lex $P1494 - .const 'Sub' $P1478 = "85_1275511714.5903" - capture_lex $P1478 - new $P1468, 'ExceptionHandler' - set_addr $P1468, control_1467 - $P1468."handle_types"(57) - push_eh $P1468 - .lex "self", self - .lex "$/", param_1469 -.annotate 'line', 435 - new $P1470, "Undef" - .lex "$str", $P1470 -.annotate 'line', 436 - new $P1471, "Undef" - .lex "$past", $P1471 -.annotate 'line', 435 - new $P1472, "String" - assign $P1472, "" - store_lex "$str", $P1472 - find_lex $P1473, "$past" -.annotate 'line', 437 - find_lex $P1475, "$/" - unless_null $P1475, vivify_331 - $P1475 = root_new ['parrot';'Hash'] + new $P1431, "Undef" + .lex "$n", $P1431 +.annotate 'line', 423 + find_lex $P1432, "$/" + unless_null $P1432, vivify_331 + $P1432 = root_new ['parrot';'Hash'] vivify_331: - set $P1476, $P1475["name"] - unless_null $P1476, vivify_332 - new $P1476, "Undef" + set $P1433, $P1432["cclass_elem"] + unless_null $P1433, vivify_332 + new $P1433, "Undef" vivify_332: - if $P1476, if_1474 -.annotate 'line', 441 - find_lex $P1489, "$/" - unless_null $P1489, vivify_333 - $P1489 = root_new ['parrot';'Hash'] + store_lex "$clist", $P1433 +.annotate 'line', 424 + find_lex $P1434, "$clist" + unless_null $P1434, vivify_333 + $P1434 = root_new ['parrot';'ResizablePMCArray'] vivify_333: - set $P1490, $P1489["charspec"] - unless_null $P1490, vivify_334 - new $P1490, "Undef" + set $P1435, $P1434[0] + unless_null $P1435, vivify_334 + new $P1435, "Undef" vivify_334: - defined $I1491, $P1490 - unless $I1491, for_undef_335 - iter $P1488, $P1490 - new $P1520, 'ExceptionHandler' - set_addr $P1520, loop1519_handler - $P1520."handle_types"(64, 66, 65) - push_eh $P1520 - loop1519_test: - unless $P1488, loop1519_done - shift $P1492, $P1488 - loop1519_redo: - .const 'Sub' $P1494 = "86_1275511714.5903" - capture_lex $P1494 - $P1494($P1492) - loop1519_next: - goto loop1519_test - loop1519_handler: + $P1436 = $P1435."ast"() + store_lex "$past", $P1436 +.annotate 'line', 425 + find_lex $P1440, "$past" + $P1441 = $P1440."negate"() + if $P1441, if_1439 + set $P1438, $P1441 + goto if_1439_end + if_1439: + find_lex $P1442, "$past" + $S1443 = $P1442."pasttype"() + iseq $I1444, $S1443, "subrule" + new $P1438, 'Integer' + set $P1438, $I1444 + if_1439_end: + unless $P1438, if_1437_end +.annotate 'line', 426 + find_lex $P1445, "$past" + $P1445."subtype"("zerowidth") +.annotate 'line', 427 + get_hll_global $P1446, ["PAST"], "Regex" + find_lex $P1447, "$past" +.annotate 'line', 429 + get_hll_global $P1448, ["PAST"], "Regex" + $P1449 = $P1448."new"("charclass" :named("pasttype"), "." :named("subtype")) + find_lex $P1450, "$/" + $P1451 = $P1446."new"($P1447, $P1449, $P1450 :named("node")) +.annotate 'line', 427 + store_lex "$past", $P1451 + if_1437_end: +.annotate 'line', 433 + new $P1452, "Integer" + assign $P1452, 1 + store_lex "$i", $P1452 +.annotate 'line', 434 + find_lex $P1453, "$clist" + set $N1454, $P1453 + new $P1455, 'Float' + set $P1455, $N1454 + store_lex "$n", $P1455 +.annotate 'line', 435 + new $P1486, 'ExceptionHandler' + set_addr $P1486, loop1485_handler + $P1486."handle_types"(64, 66, 65) + push_eh $P1486 + loop1485_test: + find_lex $P1456, "$i" + set $N1457, $P1456 + find_lex $P1458, "$n" + set $N1459, $P1458 + islt $I1460, $N1457, $N1459 + unless $I1460, loop1485_done + loop1485_redo: + .const 'Sub' $P1462 = "84_1275600002.0917" + capture_lex $P1462 + $P1462() + loop1485_next: + goto loop1485_test + loop1485_handler: .local pmc exception .get_results (exception) - getattribute $P1521, exception, 'type' - eq $P1521, 64, loop1519_next - eq $P1521, 66, loop1519_redo - loop1519_done: + getattribute $P1487, exception, 'type' + eq $P1487, 64, loop1485_next + eq $P1487, 66, loop1485_redo + loop1485_done: pop_eh - for_undef_335: -.annotate 'line', 466 - get_hll_global $P1522, ["PAST"], "Regex" - find_lex $P1523, "$str" - find_lex $P1524, "$/" - $P1525 = $P1522."new"($P1523, "enumcharlist" :named("pasttype"), $P1524 :named("node")) - store_lex "$past", $P1525 -.annotate 'line', 440 - goto if_1474_end - if_1474: -.annotate 'line', 437 - .const 'Sub' $P1478 = "85_1275511714.5903" - capture_lex $P1478 - $P1478() - if_1474_end: -.annotate 'line', 468 - find_lex $P1526, "$past" - find_lex $P1527, "$/" - unless_null $P1527, vivify_347 - $P1527 = root_new ['parrot';'Hash'] - vivify_347: - set $P1528, $P1527["sign"] - unless_null $P1528, vivify_348 - new $P1528, "Undef" - vivify_348: - set $S1529, $P1528 - iseq $I1530, $S1529, "-" - $P1526."negate"($I1530) -.annotate 'line', 469 - find_lex $P1531, "$/" - find_lex $P1532, "$past" - $P1533 = $P1531."!make"($P1532) -.annotate 'line', 434 - .return ($P1533) - control_1467: +.annotate 'line', 446 + find_lex $P1488, "$/" + find_lex $P1489, "$past" + $P1490 = $P1488."!make"($P1489) +.annotate 'line', 422 + .return ($P1490) + control_1425: .local pmc exception .get_results (exception) - getattribute $P1534, exception, "payload" - .return ($P1534) + getattribute $P1491, exception, "payload" + .return ($P1491) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block1493" :anon :subid("86_1275511714.5903") :outer("84_1275511714.5903") - .param pmc param_1495 -.annotate 'line', 441 - .const 'Sub' $P1501 = "87_1275511714.5903" - capture_lex $P1501 - .lex "$_", param_1495 -.annotate 'line', 442 - find_lex $P1498, "$_" - unless_null $P1498, vivify_336 - $P1498 = root_new ['parrot';'ResizablePMCArray'] +.sub "_block1461" :anon :subid("84_1275600002.0917") :outer("83_1275600002.0917") +.annotate 'line', 436 + new $P1463, "Undef" + .lex "$ast", $P1463 + find_lex $P1464, "$i" + set $I1465, $P1464 + find_lex $P1466, "$clist" + unless_null $P1466, vivify_335 + $P1466 = root_new ['parrot';'ResizablePMCArray'] + vivify_335: + set $P1467, $P1466[$I1465] + unless_null $P1467, vivify_336 + new $P1467, "Undef" vivify_336: - set $P1499, $P1498[1] - unless_null $P1499, vivify_337 - new $P1499, "Undef" - vivify_337: - if $P1499, if_1497 -.annotate 'line', 464 - find_lex $P1515, "$str" - find_lex $P1516, "$_" - unless_null $P1516, vivify_338 - $P1516 = root_new ['parrot';'ResizablePMCArray'] - vivify_338: - set $P1517, $P1516[0] - unless_null $P1517, vivify_339 - new $P1517, "Undef" - vivify_339: - concat $P1518, $P1515, $P1517 - store_lex "$str", $P1518 - set $P1496, $P1518 + $P1468 = $P1467."ast"() + store_lex "$ast", $P1468 +.annotate 'line', 437 + find_lex $P1470, "$ast" + $P1471 = $P1470."negate"() + if $P1471, if_1469 .annotate 'line', 442 - goto if_1497_end - if_1497: - .const 'Sub' $P1501 = "87_1275511714.5903" - capture_lex $P1501 - $P1514 = $P1501() - set $P1496, $P1514 - if_1497_end: + get_hll_global $P1478, ["PAST"], "Regex" + find_lex $P1479, "$past" + find_lex $P1480, "$ast" + find_lex $P1481, "$/" + $P1482 = $P1478."new"($P1479, $P1480, "alt" :named("pasttype"), $P1481 :named("node")) + store_lex "$past", $P1482 .annotate 'line', 441 - .return ($P1496) + goto if_1469_end + if_1469: +.annotate 'line', 438 + find_lex $P1472, "$ast" + $P1472."subtype"("zerowidth") +.annotate 'line', 439 + get_hll_global $P1473, ["PAST"], "Regex" + find_lex $P1474, "$ast" + find_lex $P1475, "$past" + find_lex $P1476, "$/" + $P1477 = $P1473."new"($P1474, $P1475, "concat" :named("pasttype"), $P1476 :named("node")) + store_lex "$past", $P1477 + if_1469_end: +.annotate 'line', 444 + find_lex $P1483, "$i" + add $P1484, $P1483, 1 + store_lex "$i", $P1484 +.annotate 'line', 435 + .return ($P1484) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block1500" :anon :subid("87_1275511714.5903") :outer("86_1275511714.5903") -.annotate 'line', 443 +.sub "cclass_elem" :subid("85_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1495 +.annotate 'line', 449 + .const 'Sub' $P1520 = "87_1275600002.0917" + capture_lex $P1520 + .const 'Sub' $P1504 = "86_1275600002.0917" + capture_lex $P1504 + new $P1494, 'ExceptionHandler' + set_addr $P1494, control_1493 + $P1494."handle_types"(57) + push_eh $P1494 + .lex "self", self + .lex "$/", param_1495 +.annotate 'line', 450 + new $P1496, "Undef" + .lex "$str", $P1496 +.annotate 'line', 451 + new $P1497, "Undef" + .lex "$past", $P1497 +.annotate 'line', 450 + new $P1498, "String" + assign $P1498, "" + store_lex "$str", $P1498 + find_lex $P1499, "$past" +.annotate 'line', 452 + find_lex $P1501, "$/" + unless_null $P1501, vivify_337 + $P1501 = root_new ['parrot';'Hash'] + vivify_337: + set $P1502, $P1501["name"] + unless_null $P1502, vivify_338 new $P1502, "Undef" - .lex "$a", $P1502 -.annotate 'line', 444 - new $P1503, "Undef" - .lex "$b", $P1503 -.annotate 'line', 445 - new $P1504, "Undef" - .lex "$c", $P1504 -.annotate 'line', 443 - find_lex $P1505, "$_" - unless_null $P1505, vivify_340 - $P1505 = root_new ['parrot';'ResizablePMCArray'] + vivify_338: + if $P1502, if_1500 +.annotate 'line', 456 + find_lex $P1515, "$/" + unless_null $P1515, vivify_339 + $P1515 = root_new ['parrot';'Hash'] + vivify_339: + set $P1516, $P1515["charspec"] + unless_null $P1516, vivify_340 + new $P1516, "Undef" vivify_340: - set $P1506, $P1505[0] - unless_null $P1506, vivify_341 - new $P1506, "Undef" - vivify_341: - store_lex "$a", $P1506 -.annotate 'line', 444 - find_lex $P1507, "$_" - unless_null $P1507, vivify_342 - $P1507 = root_new ['parrot';'ResizablePMCArray'] + defined $I1517, $P1516 + unless $I1517, for_undef_341 + iter $P1514, $P1516 + new $P1546, 'ExceptionHandler' + set_addr $P1546, loop1545_handler + $P1546."handle_types"(64, 66, 65) + push_eh $P1546 + loop1545_test: + unless $P1514, loop1545_done + shift $P1518, $P1514 + loop1545_redo: + .const 'Sub' $P1520 = "87_1275600002.0917" + capture_lex $P1520 + $P1520($P1518) + loop1545_next: + goto loop1545_test + loop1545_handler: + .local pmc exception + .get_results (exception) + getattribute $P1547, exception, 'type' + eq $P1547, 64, loop1545_next + eq $P1547, 66, loop1545_redo + loop1545_done: + pop_eh + for_undef_341: +.annotate 'line', 481 + get_hll_global $P1548, ["PAST"], "Regex" + find_lex $P1549, "$str" + find_lex $P1550, "$/" + $P1551 = $P1548."new"($P1549, "enumcharlist" :named("pasttype"), $P1550 :named("node")) + store_lex "$past", $P1551 +.annotate 'line', 455 + goto if_1500_end + if_1500: +.annotate 'line', 452 + .const 'Sub' $P1504 = "86_1275600002.0917" + capture_lex $P1504 + $P1504() + if_1500_end: +.annotate 'line', 483 + find_lex $P1552, "$past" + find_lex $P1553, "$/" + unless_null $P1553, vivify_353 + $P1553 = root_new ['parrot';'Hash'] + vivify_353: + set $P1554, $P1553["sign"] + unless_null $P1554, vivify_354 + new $P1554, "Undef" + vivify_354: + set $S1555, $P1554 + iseq $I1556, $S1555, "-" + $P1552."negate"($I1556) +.annotate 'line', 484 + find_lex $P1557, "$/" + find_lex $P1558, "$past" + $P1559 = $P1557."!make"($P1558) +.annotate 'line', 449 + .return ($P1559) + control_1493: + .local pmc exception + .get_results (exception) + getattribute $P1560, exception, "payload" + .return ($P1560) +.end + + +.namespace ["Regex";"P6Regex";"Actions"] +.sub "_block1519" :anon :subid("87_1275600002.0917") :outer("85_1275600002.0917") + .param pmc param_1521 +.annotate 'line', 456 + .const 'Sub' $P1527 = "88_1275600002.0917" + capture_lex $P1527 + .lex "$_", param_1521 +.annotate 'line', 457 + find_lex $P1524, "$_" + unless_null $P1524, vivify_342 + $P1524 = root_new ['parrot';'ResizablePMCArray'] vivify_342: - set $P1508, $P1507[1] - unless_null $P1508, vivify_343 - $P1508 = root_new ['parrot';'ResizablePMCArray'] + set $P1525, $P1524[1] + unless_null $P1525, vivify_343 + new $P1525, "Undef" vivify_343: - set $P1509, $P1508[0] - unless_null $P1509, vivify_344 - new $P1509, "Undef" + if $P1525, if_1523 +.annotate 'line', 479 + find_lex $P1541, "$str" + find_lex $P1542, "$_" + unless_null $P1542, vivify_344 + $P1542 = root_new ['parrot';'ResizablePMCArray'] vivify_344: - store_lex "$b", $P1509 -.annotate 'line', 445 + set $P1543, $P1542[0] + unless_null $P1543, vivify_345 + new $P1543, "Undef" + vivify_345: + concat $P1544, $P1541, $P1543 + store_lex "$str", $P1544 + set $P1522, $P1544 +.annotate 'line', 457 + goto if_1523_end + if_1523: + .const 'Sub' $P1527 = "88_1275600002.0917" + capture_lex $P1527 + $P1540 = $P1527() + set $P1522, $P1540 + if_1523_end: +.annotate 'line', 456 + .return ($P1522) +.end + + +.namespace ["Regex";"P6Regex";"Actions"] +.sub "_block1526" :anon :subid("88_1275600002.0917") :outer("87_1275600002.0917") +.annotate 'line', 458 + new $P1528, "Undef" + .lex "$a", $P1528 +.annotate 'line', 459 + new $P1529, "Undef" + .lex "$b", $P1529 +.annotate 'line', 460 + new $P1530, "Undef" + .lex "$c", $P1530 +.annotate 'line', 458 + find_lex $P1531, "$_" + unless_null $P1531, vivify_346 + $P1531 = root_new ['parrot';'ResizablePMCArray'] + vivify_346: + set $P1532, $P1531[0] + unless_null $P1532, vivify_347 + new $P1532, "Undef" + vivify_347: + store_lex "$a", $P1532 +.annotate 'line', 459 + find_lex $P1533, "$_" + unless_null $P1533, vivify_348 + $P1533 = root_new ['parrot';'ResizablePMCArray'] + vivify_348: + set $P1534, $P1533[1] + unless_null $P1534, vivify_349 + $P1534 = root_new ['parrot';'ResizablePMCArray'] + vivify_349: + set $P1535, $P1534[0] + unless_null $P1535, vivify_350 + new $P1535, "Undef" + vivify_350: + store_lex "$b", $P1535 +.annotate 'line', 460 $P0 = find_lex '$a' $S0 = $P0 @@ -11795,160 +11884,160 @@ Regex::P6Regex - Parser/compiler for Perl 6 regexes inc $I0 goto cclass_loop cclass_done: - $P1510 = box $S2 + $P1536 = box $S2 - store_lex "$c", $P1510 -.annotate 'line', 462 - find_lex $P1511, "$str" - find_lex $P1512, "$c" - concat $P1513, $P1511, $P1512 - store_lex "$str", $P1513 -.annotate 'line', 442 - .return ($P1513) + store_lex "$c", $P1536 +.annotate 'line', 477 + find_lex $P1537, "$str" + find_lex $P1538, "$c" + concat $P1539, $P1537, $P1538 + store_lex "$str", $P1539 +.annotate 'line', 457 + .return ($P1539) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block1477" :anon :subid("85_1275511714.5903") :outer("84_1275511714.5903") -.annotate 'line', 438 - new $P1479, "Undef" - .lex "$name", $P1479 - find_lex $P1480, "$/" - unless_null $P1480, vivify_345 - $P1480 = root_new ['parrot';'Hash'] - vivify_345: - set $P1481, $P1480["name"] - unless_null $P1481, vivify_346 - new $P1481, "Undef" - vivify_346: - set $S1482, $P1481 - new $P1483, 'String' - set $P1483, $S1482 - store_lex "$name", $P1483 -.annotate 'line', 439 - get_hll_global $P1484, ["PAST"], "Regex" - find_lex $P1485, "$name" - find_lex $P1486, "$/" - $P1487 = $P1484."new"($P1485, "subrule" :named("pasttype"), "method" :named("subtype"), $P1486 :named("node")) - store_lex "$past", $P1487 -.annotate 'line', 437 - .return ($P1487) +.sub "_block1503" :anon :subid("86_1275600002.0917") :outer("85_1275600002.0917") +.annotate 'line', 453 + new $P1505, "Undef" + .lex "$name", $P1505 + find_lex $P1506, "$/" + unless_null $P1506, vivify_351 + $P1506 = root_new ['parrot';'Hash'] + vivify_351: + set $P1507, $P1506["name"] + unless_null $P1507, vivify_352 + new $P1507, "Undef" + vivify_352: + set $S1508, $P1507 + new $P1509, 'String' + set $P1509, $S1508 + store_lex "$name", $P1509 +.annotate 'line', 454 + get_hll_global $P1510, ["PAST"], "Regex" + find_lex $P1511, "$name" + find_lex $P1512, "$/" + $P1513 = $P1510."new"($P1511, "subrule" :named("pasttype"), "method" :named("subtype"), $P1512 :named("node")) + store_lex "$past", $P1513 +.annotate 'line', 452 + .return ($P1513) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "mod_internal" :subid("88_1275511714.5903") :method :outer("11_1275511714.5903") - .param pmc param_1538 -.annotate 'line', 472 - new $P1537, 'ExceptionHandler' - set_addr $P1537, control_1536 - $P1537."handle_types"(57) - push_eh $P1537 +.sub "mod_internal" :subid("89_1275600002.0917") :method :outer("11_1275600002.0917") + .param pmc param_1564 +.annotate 'line', 487 + new $P1563, 'ExceptionHandler' + set_addr $P1563, control_1562 + $P1563."handle_types"(57) + push_eh $P1563 .lex "self", self - .lex "$/", param_1538 -.annotate 'line', 473 - $P1539 = root_new ['parrot';'Hash'] - .lex "%mods", $P1539 -.annotate 'line', 474 - new $P1540, "Undef" - .lex "$n", $P1540 -.annotate 'line', 473 - get_global $P1541, "@MODIFIERS" - unless_null $P1541, vivify_349 - $P1541 = root_new ['parrot';'ResizablePMCArray'] - vivify_349: - set $P1542, $P1541[0] - unless_null $P1542, vivify_350 - new $P1542, "Undef" - vivify_350: - store_lex "%mods", $P1542 -.annotate 'line', 474 - find_lex $P1545, "$/" - unless_null $P1545, vivify_351 - $P1545 = root_new ['parrot';'Hash'] - vivify_351: - set $P1546, $P1545["n"] - unless_null $P1546, vivify_352 - $P1546 = root_new ['parrot';'ResizablePMCArray'] - vivify_352: - set $P1547, $P1546[0] - unless_null $P1547, vivify_353 - new $P1547, "Undef" - vivify_353: - set $S1548, $P1547 - isgt $I1549, $S1548, "" - if $I1549, if_1544 - new $P1554, "Integer" - assign $P1554, 1 - set $P1543, $P1554 - goto if_1544_end - if_1544: - find_lex $P1550, "$/" - unless_null $P1550, vivify_354 - $P1550 = root_new ['parrot';'Hash'] - vivify_354: - set $P1551, $P1550["n"] - unless_null $P1551, vivify_355 - $P1551 = root_new ['parrot';'ResizablePMCArray'] + .lex "$/", param_1564 +.annotate 'line', 488 + $P1565 = root_new ['parrot';'Hash'] + .lex "%mods", $P1565 +.annotate 'line', 489 + new $P1566, "Undef" + .lex "$n", $P1566 +.annotate 'line', 488 + get_global $P1567, "@MODIFIERS" + unless_null $P1567, vivify_355 + $P1567 = root_new ['parrot';'ResizablePMCArray'] vivify_355: - set $P1552, $P1551[0] - unless_null $P1552, vivify_356 - new $P1552, "Undef" + set $P1568, $P1567[0] + unless_null $P1568, vivify_356 + new $P1568, "Undef" vivify_356: - set $N1553, $P1552 - new $P1543, 'Float' - set $P1543, $N1553 - if_1544_end: - store_lex "$n", $P1543 -.annotate 'line', 475 - find_lex $P1555, "$n" - find_lex $P1556, "$/" - unless_null $P1556, vivify_357 - $P1556 = root_new ['parrot';'Hash'] + store_lex "%mods", $P1568 +.annotate 'line', 489 + find_lex $P1571, "$/" + unless_null $P1571, vivify_357 + $P1571 = root_new ['parrot';'Hash'] vivify_357: - set $P1557, $P1556["mod_ident"] - unless_null $P1557, vivify_358 - $P1557 = root_new ['parrot';'Hash'] + set $P1572, $P1571["n"] + unless_null $P1572, vivify_358 + $P1572 = root_new ['parrot';'ResizablePMCArray'] vivify_358: - set $P1558, $P1557["sym"] - unless_null $P1558, vivify_359 - new $P1558, "Undef" + set $P1573, $P1572[0] + unless_null $P1573, vivify_359 + new $P1573, "Undef" vivify_359: - set $S1559, $P1558 - find_lex $P1560, "%mods" - unless_null $P1560, vivify_360 - $P1560 = root_new ['parrot';'Hash'] - store_lex "%mods", $P1560 + set $S1574, $P1573 + isgt $I1575, $S1574, "" + if $I1575, if_1570 + new $P1580, "Integer" + assign $P1580, 1 + set $P1569, $P1580 + goto if_1570_end + if_1570: + find_lex $P1576, "$/" + unless_null $P1576, vivify_360 + $P1576 = root_new ['parrot';'Hash'] vivify_360: - set $P1560[$S1559], $P1555 -.annotate 'line', 476 - find_lex $P1561, "$/" - $P1562 = $P1561."!make"(0) -.annotate 'line', 472 - .return ($P1562) - control_1536: + set $P1577, $P1576["n"] + unless_null $P1577, vivify_361 + $P1577 = root_new ['parrot';'ResizablePMCArray'] + vivify_361: + set $P1578, $P1577[0] + unless_null $P1578, vivify_362 + new $P1578, "Undef" + vivify_362: + set $N1579, $P1578 + new $P1569, 'Float' + set $P1569, $N1579 + if_1570_end: + store_lex "$n", $P1569 +.annotate 'line', 490 + find_lex $P1581, "$n" + find_lex $P1582, "$/" + unless_null $P1582, vivify_363 + $P1582 = root_new ['parrot';'Hash'] + vivify_363: + set $P1583, $P1582["mod_ident"] + unless_null $P1583, vivify_364 + $P1583 = root_new ['parrot';'Hash'] + vivify_364: + set $P1584, $P1583["sym"] + unless_null $P1584, vivify_365 + new $P1584, "Undef" + vivify_365: + set $S1585, $P1584 + find_lex $P1586, "%mods" + unless_null $P1586, vivify_366 + $P1586 = root_new ['parrot';'Hash'] + store_lex "%mods", $P1586 + vivify_366: + set $P1586[$S1585], $P1581 +.annotate 'line', 491 + find_lex $P1587, "$/" + $P1588 = $P1587."!make"(0) +.annotate 'line', 487 + .return ($P1588) + control_1562: .local pmc exception .get_results (exception) - getattribute $P1563, exception, "payload" - .return ($P1563) + getattribute $P1589, exception, "payload" + .return ($P1589) .end .namespace ["Regex";"P6Regex";"Actions"] -.sub "_block1568" :load :anon :subid("89_1275511714.5903") +.sub "_block1594" :load :anon :subid("90_1275600002.0917") .annotate 'line', 4 - .const 'Sub' $P1570 = "11_1275511714.5903" - $P1571 = $P1570() - .return ($P1571) + .const 'Sub' $P1596 = "11_1275600002.0917" + $P1597 = $P1596() + .return ($P1597) .end .namespace [] -.sub "_block1574" :load :anon :subid("90_1275511714.5903") +.sub "_block1600" :load :anon :subid("91_1275600002.0917") .annotate 'line', 1 - .const 'Sub' $P1576 = "10_1275511714.5903" - $P1577 = $P1576() - .return ($P1577) + .const 'Sub' $P1602 = "10_1275600002.0917" + $P1603 = $P1602() + .return ($P1603) .end # .include 'src/cheats/p6regex-grammar.pir' diff --git a/src/stage0/nqp-setting.nqp b/src/stage0/nqp-setting.nqp index c3c49e4..af4e5c4 100644 --- a/src/stage0/nqp-setting.nqp +++ b/src/stage0/nqp-setting.nqp @@ -213,9 +213,10 @@ Returns the contents of C<$filename> as a single string. =end our sub slurp ($filename) { - my $handle := pir::open__Pss($file, 'r'); + my $handle := FileHandle.new(); + $handle.open($file, 'r'); my $contents := $handle.readall; - pir::close($handle); + $handle.close(); $contents; } @@ -225,9 +226,10 @@ Write the string value of C<$contents> to C<$filename>. =end item our sub spew($filename, $contents) { - my $handle := pir::open__Pss($filename, 'w'); + my $handle := FileHandle.new(); + $handle.open($filename, 'w'); $handle.print($contents); - pir::close($handle); + $handle.close(); } # vim: ft=perl6