Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

14213 lines (13683 sloc) 424.731 kb
# Copyright (C) 2009, The Perl Foundation.
#
=head1 NAME
Regex::P6Regex - Parser/compiler for Perl 6 regexes
=head1 DESCRIPTION
=cut
.sub '' :anon :load :init
load_bytecode 'HLL.pbc'
.end
### .include 'gen/p6regex-grammar.pir'
.namespace []
.sub "_block1000" :anon :subid("10_1308626176.8564")
.annotate 'line', 0
.const 'Sub' $P1003 = "11_1308626176.8564"
capture_lex $P1003
.annotate 'line', 1
$P0 = find_dynamic_lex "$*CTXSAVE"
if null $P0 goto ctxsave_done
$I0 = can $P0, "ctxsave"
unless $I0 goto ctxsave_done
$P0."ctxsave"()
ctxsave_done:
.annotate 'line', 3
.const 'Sub' $P1003 = "11_1308626176.8564"
capture_lex $P1003
$P101 = $P1003()
.annotate 'line', 1
.return ($P101)
.const 'Sub' $P1468 = "174_1308626176.8564"
.return ($P1468)
.end
.namespace []
.sub "" :load :init :subid("post175") :outer("10_1308626176.8564")
.annotate 'line', 0
.const 'Sub' $P1001 = "10_1308626176.8564"
.local pmc block
set block, $P1001
$P1470 = get_root_global ["parrot"], "P6metaclass"
$P1470."new_class"("Regex::P6Regex::Grammar", "HLL::Grammar" :named("parent"))
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "_block1002" :subid("11_1308626176.8564") :outer("10_1308626176.8564")
.annotate 'line', 3
.const 'Sub' $P1458 = "171_1308626176.8564"
capture_lex $P1458
.const 'Sub' $P1452 = "169_1308626176.8564"
capture_lex $P1452
.const 'Sub' $P1446 = "167_1308626176.8564"
capture_lex $P1446
.const 'Sub' $P1430 = "162_1308626176.8564"
capture_lex $P1430
.const 'Sub' $P1397 = "156_1308626176.8564"
capture_lex $P1397
.const 'Sub' $P1386 = "153_1308626176.8564"
capture_lex $P1386
.const 'Sub' $P1376 = "150_1308626176.8564"
capture_lex $P1376
.const 'Sub' $P1372 = "148_1308626176.8564"
capture_lex $P1372
.const 'Sub' $P1363 = "145_1308626176.8564"
capture_lex $P1363
.const 'Sub' $P1354 = "142_1308626176.8564"
capture_lex $P1354
.const 'Sub' $P1348 = "138_1308626176.8564"
capture_lex $P1348
.const 'Sub' $P1342 = "135_1308626176.8564"
capture_lex $P1342
.const 'Sub' $P1338 = "133_1308626176.8564"
capture_lex $P1338
.const 'Sub' $P1334 = "131_1308626176.8564"
capture_lex $P1334
.const 'Sub' $P1330 = "129_1308626176.8564"
capture_lex $P1330
.const 'Sub' $P1326 = "127_1308626176.8564"
capture_lex $P1326
.const 'Sub' $P1321 = "125_1308626176.8564"
capture_lex $P1321
.const 'Sub' $P1315 = "123_1308626176.8564"
capture_lex $P1315
.const 'Sub' $P1309 = "121_1308626176.8564"
capture_lex $P1309
.const 'Sub' $P1304 = "119_1308626176.8564"
capture_lex $P1304
.const 'Sub' $P1299 = "117_1308626176.8564"
capture_lex $P1299
.const 'Sub' $P1294 = "115_1308626176.8564"
capture_lex $P1294
.const 'Sub' $P1289 = "113_1308626176.8564"
capture_lex $P1289
.const 'Sub' $P1284 = "111_1308626176.8564"
capture_lex $P1284
.const 'Sub' $P1279 = "109_1308626176.8564"
capture_lex $P1279
.const 'Sub' $P1274 = "107_1308626176.8564"
capture_lex $P1274
.const 'Sub' $P1269 = "105_1308626176.8564"
capture_lex $P1269
.const 'Sub' $P1260 = "101_1308626176.8564"
capture_lex $P1260
.const 'Sub' $P1251 = "99_1308626176.8564"
capture_lex $P1251
.const 'Sub' $P1246 = "97_1308626176.8564"
capture_lex $P1246
.const 'Sub' $P1235 = "95_1308626176.8564"
capture_lex $P1235
.const 'Sub' $P1230 = "93_1308626176.8564"
capture_lex $P1230
.const 'Sub' $P1226 = "91_1308626176.8564"
capture_lex $P1226
.const 'Sub' $P1222 = "89_1308626176.8564"
capture_lex $P1222
.const 'Sub' $P1218 = "87_1308626176.8564"
capture_lex $P1218
.const 'Sub' $P1212 = "85_1308626176.8564"
capture_lex $P1212
.const 'Sub' $P1206 = "83_1308626176.8564"
capture_lex $P1206
.const 'Sub' $P1201 = "81_1308626176.8564"
capture_lex $P1201
.const 'Sub' $P1196 = "79_1308626176.8564"
capture_lex $P1196
.const 'Sub' $P1191 = "77_1308626176.8564"
capture_lex $P1191
.const 'Sub' $P1186 = "75_1308626176.8564"
capture_lex $P1186
.const 'Sub' $P1181 = "73_1308626176.8564"
capture_lex $P1181
.const 'Sub' $P1176 = "71_1308626176.8564"
capture_lex $P1176
.const 'Sub' $P1171 = "69_1308626176.8564"
capture_lex $P1171
.const 'Sub' $P1167 = "67_1308626176.8564"
capture_lex $P1167
.const 'Sub' $P1163 = "65_1308626176.8564"
capture_lex $P1163
.const 'Sub' $P1159 = "63_1308626176.8564"
capture_lex $P1159
.const 'Sub' $P1155 = "61_1308626176.8564"
capture_lex $P1155
.const 'Sub' $P1151 = "59_1308626176.8564"
capture_lex $P1151
.const 'Sub' $P1139 = "54_1308626176.8564"
capture_lex $P1139
.const 'Sub' $P1125 = "52_1308626176.8564"
capture_lex $P1125
.const 'Sub' $P1106 = "46_1308626176.8564"
capture_lex $P1106
.const 'Sub' $P1101 = "44_1308626176.8564"
capture_lex $P1101
.const 'Sub' $P1096 = "42_1308626176.8564"
capture_lex $P1096
.const 'Sub' $P1091 = "40_1308626176.8564"
capture_lex $P1091
.const 'Sub' $P1078 = "35_1308626176.8564"
capture_lex $P1078
.const 'Sub' $P1068 = "32_1308626176.8564"
capture_lex $P1068
.const 'Sub' $P1062 = "30_1308626176.8564"
capture_lex $P1062
.const 'Sub' $P1055 = "28_1308626176.8564"
capture_lex $P1055
.const 'Sub' $P1046 = "26_1308626176.8564"
capture_lex $P1046
.const 'Sub' $P1041 = "24_1308626176.8564"
capture_lex $P1041
.const 'Sub' $P1036 = "22_1308626176.8564"
capture_lex $P1036
.const 'Sub' $P1030 = "20_1308626176.8564"
capture_lex $P1030
.const 'Sub' $P1025 = "18_1308626176.8564"
capture_lex $P1025
.const 'Sub' $P1016 = "15_1308626176.8564"
capture_lex $P1016
.const 'Sub' $P1010 = "13_1308626176.8564"
capture_lex $P1010
.const 'Sub' $P1004 = "12_1308626176.8564"
capture_lex $P1004
$P0 = find_dynamic_lex "$*CTXSAVE"
if null $P0 goto ctxsave_done
$I0 = can $P0, "ctxsave"
unless $I0 goto ctxsave_done
$P0."ctxsave"()
ctxsave_done:
.const 'Sub' $P1458 = "171_1308626176.8564"
capture_lex $P1458
.return ($P1458)
.const 'Sub' $P1465 = "173_1308626176.8564"
.return ($P1465)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.include "except_types.pasm"
.sub "obs" :subid("12_1308626176.8564") :method :outer("11_1308626176.8564")
.param pmc param_1007
.param pmc param_1008
.param pmc param_1009 :optional
.param int has_param_1009 :opt_flag
.annotate 'line', 3
new $P1006, ['ExceptionHandler'], .CONTROL_RETURN
set_label $P1006, control_1005
push_eh $P1006
.lex "self", self
.lex "$old", param_1007
.lex "$new", param_1008
if has_param_1009, optparam_176
new $P100, "String"
assign $P100, " in Perl 6"
set param_1009, $P100
optparam_176:
.lex "$when", param_1009
.annotate 'line', 4
find_lex $P101, "self"
new $P102, "String"
assign $P102, "Unsupported use of "
find_lex $P103, "$old"
set $S100, $P103
concat $P104, $P102, $S100
concat $P105, $P104, ";"
.annotate 'line', 5
find_lex $P106, "$when"
set $S101, $P106
concat $P107, $P105, $S101
concat $P108, $P107, " please use "
find_lex $P109, "$new"
set $S102, $P109
concat $P110, $P108, $S102
$P111 = $P101."panic"($P110)
.annotate 'line', 3
.return ($P111)
control_1005:
.local pmc exception
.get_results (exception)
getattribute $P101, exception, "payload"
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "ws" :subid("13_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1011_tgt
.local int rx1011_pos
.local int rx1011_off
.local int rx1011_eos
.local int rx1011_rep
.local pmc rx1011_cur
.local pmc rx1011_debug
(rx1011_cur, rx1011_pos, rx1011_tgt, $I10) = self."!cursor_start"()
getattribute rx1011_debug, rx1011_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1011_cur
.local pmc match
.lex "$/", match
length rx1011_eos, rx1011_tgt
gt rx1011_pos, rx1011_eos, rx1011_done
set rx1011_off, 0
lt rx1011_pos, 2, rx1011_start
sub rx1011_off, rx1011_pos, 1
substr rx1011_tgt, rx1011_tgt, rx1011_off
rx1011_start:
eq $I10, 1, rx1011_restart
if_null rx1011_debug, debug_177
rx1011_cur."!cursor_debug"("START", "ws")
debug_177:
$I10 = self.'from'()
ne $I10, -1, rxscan1013_done
goto rxscan1013_scan
rxscan1013_loop:
($P10) = rx1011_cur."from"()
inc $P10
set rx1011_pos, $P10
ge rx1011_pos, rx1011_eos, rxscan1013_done
rxscan1013_scan:
set_addr $I10, rxscan1013_loop
rx1011_cur."!mark_push"(0, rx1011_pos, $I10)
rxscan1013_done:
.annotate 'line', 8
# rx rxquantr1014 ** 0..*
set_addr $I10, rxquantr1014_done
rx1011_cur."!mark_push"(0, rx1011_pos, $I10)
rxquantr1014_loop:
alt1015_0:
set_addr $I10, alt1015_1
rx1011_cur."!mark_push"(0, rx1011_pos, $I10)
# rx charclass_q s r 1..-1
sub $I10, rx1011_pos, rx1011_off
find_not_cclass $I11, 32, rx1011_tgt, $I10, rx1011_eos
add $I12, $I10, 1
lt $I11, $I12, rx1011_fail
add rx1011_pos, rx1011_off, $I11
goto alt1015_end
alt1015_1:
# rx literal "#"
add $I11, rx1011_pos, 1
gt $I11, rx1011_eos, rx1011_fail
sub $I11, rx1011_pos, rx1011_off
ord $I11, rx1011_tgt, $I11
ne $I11, 35, rx1011_fail
add rx1011_pos, 1
# rx charclass_q N r 0..-1
sub $I10, rx1011_pos, rx1011_off
find_cclass $I11, 4096, rx1011_tgt, $I10, rx1011_eos
add rx1011_pos, rx1011_off, $I11
alt1015_end:
set_addr $I10, rxquantr1014_done
(rx1011_rep) = rx1011_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1014_done
rx1011_cur."!mark_push"(rx1011_rep, rx1011_pos, $I10)
goto rxquantr1014_loop
rxquantr1014_done:
# rx pass
rx1011_cur."!cursor_pass"(rx1011_pos, "ws")
if_null rx1011_debug, debug_178
rx1011_cur."!cursor_debug"("PASS", "ws", " at pos=", rx1011_pos)
debug_178:
.return (rx1011_cur)
rx1011_restart:
.annotate 'line', 3
if_null rx1011_debug, debug_179
rx1011_cur."!cursor_debug"("NEXT", "ws")
debug_179:
rx1011_fail:
(rx1011_rep, rx1011_pos, $I10, $P10) = rx1011_cur."!mark_fail"(0)
lt rx1011_pos, -1, rx1011_done
eq rx1011_pos, -1, rx1011_fail
jump $I10
rx1011_done:
rx1011_cur."!cursor_fail"()
if_null rx1011_debug, debug_180
rx1011_cur."!cursor_debug"("FAIL", "ws")
debug_180:
.return (rx1011_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__ws" :subid("14_1308626176.8564") :method
.annotate 'line', 3
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "normspace" :subid("15_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.const 'Sub' $P1021 = "17_1308626176.8564"
capture_lex $P1021
.local string rx1017_tgt
.local int rx1017_pos
.local int rx1017_off
.local int rx1017_eos
.local int rx1017_rep
.local pmc rx1017_cur
.local pmc rx1017_debug
(rx1017_cur, rx1017_pos, rx1017_tgt, $I10) = self."!cursor_start"()
getattribute rx1017_debug, rx1017_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1017_cur
.local pmc match
.lex "$/", match
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:
eq $I10, 1, rx1017_restart
if_null rx1017_debug, debug_181
rx1017_cur."!cursor_debug"("START", "normspace")
debug_181:
$I10 = self.'from'()
ne $I10, -1, rxscan1019_done
goto rxscan1019_scan
rxscan1019_loop:
($P10) = rx1017_cur."from"()
inc $P10
set rx1017_pos, $P10
ge rx1017_pos, rx1017_eos, rxscan1019_done
rxscan1019_scan:
set_addr $I10, rxscan1019_loop
rx1017_cur."!mark_push"(0, rx1017_pos, $I10)
rxscan1019_done:
.annotate 'line', 10
# rx subrule "before" subtype=zerowidth negate=
rx1017_cur."!cursor_pos"(rx1017_pos)
.const 'Sub' $P1021 = "17_1308626176.8564"
capture_lex $P1021
$P10 = rx1017_cur."before"($P1021)
unless $P10, rx1017_fail
# rx subrule "ws" subtype=method negate=
rx1017_cur."!cursor_pos"(rx1017_pos)
$P10 = rx1017_cur."ws"()
unless $P10, rx1017_fail
rx1017_pos = $P10."pos"()
# rx pass
rx1017_cur."!cursor_pass"(rx1017_pos, "normspace")
if_null rx1017_debug, debug_186
rx1017_cur."!cursor_debug"("PASS", "normspace", " at pos=", rx1017_pos)
debug_186:
.return (rx1017_cur)
rx1017_restart:
.annotate 'line', 3
if_null rx1017_debug, debug_187
rx1017_cur."!cursor_debug"("NEXT", "normspace")
debug_187:
rx1017_fail:
(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
rx1017_done:
rx1017_cur."!cursor_fail"()
if_null rx1017_debug, debug_188
rx1017_cur."!cursor_debug"("FAIL", "normspace")
debug_188:
.return (rx1017_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__normspace" :subid("16_1308626176.8564") :method
.annotate 'line', 3
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "_block1020" :anon :subid("17_1308626176.8564") :method :outer("15_1308626176.8564")
.annotate 'line', 10
.local string rx1022_tgt
.local int rx1022_pos
.local int rx1022_off
.local int rx1022_eos
.local int rx1022_rep
.local pmc rx1022_cur
.local pmc rx1022_debug
(rx1022_cur, rx1022_pos, rx1022_tgt, $I10) = self."!cursor_start"()
getattribute rx1022_debug, rx1022_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1022_cur
.local pmc match
.lex "$/", match
length rx1022_eos, rx1022_tgt
gt rx1022_pos, rx1022_eos, rx1022_done
set rx1022_off, 0
lt rx1022_pos, 2, rx1022_start
sub rx1022_off, rx1022_pos, 1
substr rx1022_tgt, rx1022_tgt, rx1022_off
rx1022_start:
eq $I10, 1, rx1022_restart
if_null rx1022_debug, debug_182
rx1022_cur."!cursor_debug"("START", "")
debug_182:
$I10 = self.'from'()
ne $I10, -1, rxscan1023_done
goto rxscan1023_scan
rxscan1023_loop:
($P10) = rx1022_cur."from"()
inc $P10
set rx1022_pos, $P10
ge rx1022_pos, rx1022_eos, rxscan1023_done
rxscan1023_scan:
set_addr $I10, rxscan1023_loop
rx1022_cur."!mark_push"(0, rx1022_pos, $I10)
rxscan1023_done:
alt1024_0:
set_addr $I10, alt1024_1
rx1022_cur."!mark_push"(0, rx1022_pos, $I10)
# rx charclass s
ge rx1022_pos, rx1022_eos, rx1022_fail
sub $I10, rx1022_pos, rx1022_off
is_cclass $I11, 32, rx1022_tgt, $I10
unless $I11, rx1022_fail
inc rx1022_pos
goto alt1024_end
alt1024_1:
# rx literal "#"
add $I11, rx1022_pos, 1
gt $I11, rx1022_eos, rx1022_fail
sub $I11, rx1022_pos, rx1022_off
ord $I11, rx1022_tgt, $I11
ne $I11, 35, rx1022_fail
add rx1022_pos, 1
alt1024_end:
# rx pass
rx1022_cur."!cursor_pass"(rx1022_pos, "")
if_null rx1022_debug, debug_183
rx1022_cur."!cursor_debug"("PASS", "", " at pos=", rx1022_pos)
debug_183:
.return (rx1022_cur)
rx1022_restart:
if_null rx1022_debug, debug_184
rx1022_cur."!cursor_debug"("NEXT", "")
debug_184:
rx1022_fail:
(rx1022_rep, rx1022_pos, $I10, $P10) = rx1022_cur."!mark_fail"(0)
lt rx1022_pos, -1, rx1022_done
eq rx1022_pos, -1, rx1022_fail
jump $I10
rx1022_done:
rx1022_cur."!cursor_fail"()
if_null rx1022_debug, debug_185
rx1022_cur."!cursor_debug"("FAIL", "")
debug_185:
.return (rx1022_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "identifier" :subid("18_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1026_tgt
.local int rx1026_pos
.local int rx1026_off
.local int rx1026_eos
.local int rx1026_rep
.local pmc rx1026_cur
.local pmc rx1026_debug
(rx1026_cur, rx1026_pos, rx1026_tgt, $I10) = self."!cursor_start"()
getattribute rx1026_debug, rx1026_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1026_cur
.local pmc match
.lex "$/", match
length rx1026_eos, rx1026_tgt
gt rx1026_pos, rx1026_eos, rx1026_done
set rx1026_off, 0
lt rx1026_pos, 2, rx1026_start
sub rx1026_off, rx1026_pos, 1
substr rx1026_tgt, rx1026_tgt, rx1026_off
rx1026_start:
eq $I10, 1, rx1026_restart
if_null rx1026_debug, debug_189
rx1026_cur."!cursor_debug"("START", "identifier")
debug_189:
$I10 = self.'from'()
ne $I10, -1, rxscan1028_done
goto rxscan1028_scan
rxscan1028_loop:
($P10) = rx1026_cur."from"()
inc $P10
set rx1026_pos, $P10
ge rx1026_pos, rx1026_eos, rxscan1028_done
rxscan1028_scan:
set_addr $I10, rxscan1028_loop
rx1026_cur."!mark_push"(0, rx1026_pos, $I10)
rxscan1028_done:
.annotate 'line', 12
# rx subrule "ident" subtype=method negate=
rx1026_cur."!cursor_pos"(rx1026_pos)
$P10 = rx1026_cur."ident"()
unless $P10, rx1026_fail
rx1026_pos = $P10."pos"()
# rx rxquantr1029 ** 0..*
set_addr $I10, rxquantr1029_done
rx1026_cur."!mark_push"(0, rx1026_pos, $I10)
rxquantr1029_loop:
# rx enumcharlist negate=0
ge rx1026_pos, rx1026_eos, rx1026_fail
sub $I10, rx1026_pos, rx1026_off
substr $S10, rx1026_tgt, $I10, 1
index $I11, "-'", $S10
lt $I11, 0, rx1026_fail
inc rx1026_pos
# rx subrule "ident" subtype=method negate=
rx1026_cur."!cursor_pos"(rx1026_pos)
$P10 = rx1026_cur."ident"()
unless $P10, rx1026_fail
rx1026_pos = $P10."pos"()
set_addr $I10, rxquantr1029_done
(rx1026_rep) = rx1026_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1029_done
rx1026_cur."!mark_push"(rx1026_rep, rx1026_pos, $I10)
goto rxquantr1029_loop
rxquantr1029_done:
# rx pass
rx1026_cur."!cursor_pass"(rx1026_pos, "identifier")
if_null rx1026_debug, debug_190
rx1026_cur."!cursor_debug"("PASS", "identifier", " at pos=", rx1026_pos)
debug_190:
.return (rx1026_cur)
rx1026_restart:
.annotate 'line', 3
if_null rx1026_debug, debug_191
rx1026_cur."!cursor_debug"("NEXT", "identifier")
debug_191:
rx1026_fail:
(rx1026_rep, rx1026_pos, $I10, $P10) = rx1026_cur."!mark_fail"(0)
lt rx1026_pos, -1, rx1026_done
eq rx1026_pos, -1, rx1026_fail
jump $I10
rx1026_done:
rx1026_cur."!cursor_fail"()
if_null rx1026_debug, debug_192
rx1026_cur."!cursor_debug"("FAIL", "identifier")
debug_192:
.return (rx1026_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__identifier" :subid("19_1308626176.8564") :method
.annotate 'line', 3
$P100 = self."!PREFIX__!subrule"("ident", "")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "arg" :subid("20_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1031_tgt
.local int rx1031_pos
.local int rx1031_off
.local int rx1031_eos
.local int rx1031_rep
.local pmc rx1031_cur
.local pmc rx1031_debug
(rx1031_cur, rx1031_pos, rx1031_tgt, $I10) = self."!cursor_start"()
getattribute rx1031_debug, rx1031_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1031_cur
.local pmc match
.lex "$/", match
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:
eq $I10, 1, rx1031_restart
if_null rx1031_debug, debug_193
rx1031_cur."!cursor_debug"("START", "arg")
debug_193:
$I10 = self.'from'()
ne $I10, -1, rxscan1033_done
goto rxscan1033_scan
rxscan1033_loop:
($P10) = rx1031_cur."from"()
inc $P10
set rx1031_pos, $P10
ge rx1031_pos, rx1031_eos, rxscan1033_done
rxscan1033_scan:
set_addr $I10, rxscan1033_loop
rx1031_cur."!mark_push"(0, rx1031_pos, $I10)
rxscan1033_done:
alt1034_0:
.annotate 'line', 15
set_addr $I10, alt1034_1
rx1031_cur."!mark_push"(0, rx1031_pos, $I10)
.annotate 'line', 16
# rx enumcharlist negate=0 zerowidth
sub $I10, rx1031_pos, rx1031_off
substr $S10, rx1031_tgt, $I10, 1
index $I11, "'", $S10
lt $I11, 0, rx1031_fail
# rx subrule "quote_EXPR" subtype=capture negate=
rx1031_cur."!cursor_pos"(rx1031_pos)
$P10 = rx1031_cur."quote_EXPR"(":q")
unless $P10, rx1031_fail
rx1031_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("quote_EXPR")
rx1031_pos = $P10."pos"()
goto alt1034_end
alt1034_1:
set_addr $I10, alt1034_2
rx1031_cur."!mark_push"(0, rx1031_pos, $I10)
.annotate 'line', 17
# rx enumcharlist negate=0 zerowidth
sub $I10, rx1031_pos, rx1031_off
substr $S10, rx1031_tgt, $I10, 1
index $I11, "\"", $S10
lt $I11, 0, rx1031_fail
# rx subrule "quote_EXPR" subtype=capture negate=
rx1031_cur."!cursor_pos"(rx1031_pos)
$P10 = rx1031_cur."quote_EXPR"(":qq")
unless $P10, rx1031_fail
rx1031_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("quote_EXPR")
rx1031_pos = $P10."pos"()
goto alt1034_end
alt1034_2:
.annotate 'line', 18
# rx subcapture "val"
set_addr $I10, rxcap_1035_fail
rx1031_cur."!mark_push"(0, rx1031_pos, $I10)
# rx charclass_q d r 1..-1
sub $I10, rx1031_pos, rx1031_off
find_not_cclass $I11, 8, rx1031_tgt, $I10, rx1031_eos
add $I12, $I10, 1
lt $I11, $I12, rx1031_fail
add rx1031_pos, rx1031_off, $I11
set_addr $I10, rxcap_1035_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"("val")
goto rxcap_1035_done
rxcap_1035_fail:
goto rx1031_fail
rxcap_1035_done:
alt1034_end:
.annotate 'line', 14
# rx pass
rx1031_cur."!cursor_pass"(rx1031_pos, "arg")
if_null rx1031_debug, debug_194
rx1031_cur."!cursor_debug"("PASS", "arg", " at pos=", rx1031_pos)
debug_194:
.return (rx1031_cur)
rx1031_restart:
.annotate 'line', 3
if_null rx1031_debug, debug_195
rx1031_cur."!cursor_debug"("NEXT", "arg")
debug_195:
rx1031_fail:
(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
rx1031_done:
rx1031_cur."!cursor_fail"()
if_null rx1031_debug, debug_196
rx1031_cur."!cursor_debug"("FAIL", "arg")
debug_196:
.return (rx1031_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__arg" :subid("21_1308626176.8564") :method
.annotate 'line', 3
new $P100, "ResizablePMCArray"
push $P100, ""
push $P100, "\""
push $P100, "'"
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "arglist" :subid("22_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1037_tgt
.local int rx1037_pos
.local int rx1037_off
.local int rx1037_eos
.local int rx1037_rep
.local pmc rx1037_cur
.local pmc rx1037_debug
(rx1037_cur, rx1037_pos, rx1037_tgt, $I10) = self."!cursor_start"()
rx1037_cur."!cursor_caparray"("arg")
getattribute rx1037_debug, rx1037_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1037_cur
.local pmc match
.lex "$/", match
length rx1037_eos, rx1037_tgt
gt rx1037_pos, rx1037_eos, rx1037_done
set rx1037_off, 0
lt rx1037_pos, 2, rx1037_start
sub rx1037_off, rx1037_pos, 1
substr rx1037_tgt, rx1037_tgt, rx1037_off
rx1037_start:
eq $I10, 1, rx1037_restart
if_null rx1037_debug, debug_197
rx1037_cur."!cursor_debug"("START", "arglist")
debug_197:
$I10 = self.'from'()
ne $I10, -1, rxscan1039_done
goto rxscan1039_scan
rxscan1039_loop:
($P10) = rx1037_cur."from"()
inc $P10
set rx1037_pos, $P10
ge rx1037_pos, rx1037_eos, rxscan1039_done
rxscan1039_scan:
set_addr $I10, rxscan1039_loop
rx1037_cur."!mark_push"(0, rx1037_pos, $I10)
rxscan1039_done:
.annotate 'line', 22
# rx subrule "ws" subtype=method negate=
rx1037_cur."!cursor_pos"(rx1037_pos)
$P10 = rx1037_cur."ws"()
unless $P10, rx1037_fail
rx1037_pos = $P10."pos"()
# rx subrule "arg" subtype=capture negate=
rx1037_cur."!cursor_pos"(rx1037_pos)
$P10 = rx1037_cur."arg"()
unless $P10, rx1037_fail
rx1037_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("arg")
rx1037_pos = $P10."pos"()
# rx subrule "ws" subtype=method negate=
rx1037_cur."!cursor_pos"(rx1037_pos)
$P10 = rx1037_cur."ws"()
unless $P10, rx1037_fail
rx1037_pos = $P10."pos"()
# rx rxquantr1040 ** 0..*
set_addr $I10, rxquantr1040_done
rx1037_cur."!mark_push"(0, rx1037_pos, $I10)
rxquantr1040_loop:
# rx subrule "ws" subtype=method negate=
rx1037_cur."!cursor_pos"(rx1037_pos)
$P10 = rx1037_cur."ws"()
unless $P10, rx1037_fail
rx1037_pos = $P10."pos"()
# rx literal ","
add $I11, rx1037_pos, 1
gt $I11, rx1037_eos, rx1037_fail
sub $I11, rx1037_pos, rx1037_off
ord $I11, rx1037_tgt, $I11
ne $I11, 44, rx1037_fail
add rx1037_pos, 1
# rx subrule "ws" subtype=method negate=
rx1037_cur."!cursor_pos"(rx1037_pos)
$P10 = rx1037_cur."ws"()
unless $P10, rx1037_fail
rx1037_pos = $P10."pos"()
# rx subrule "arg" subtype=capture negate=
rx1037_cur."!cursor_pos"(rx1037_pos)
$P10 = rx1037_cur."arg"()
unless $P10, rx1037_fail
rx1037_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("arg")
rx1037_pos = $P10."pos"()
set_addr $I10, rxquantr1040_done
(rx1037_rep) = rx1037_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1040_done
rx1037_cur."!mark_push"(rx1037_rep, rx1037_pos, $I10)
goto rxquantr1040_loop
rxquantr1040_done:
# rx subrule "ws" subtype=method negate=
rx1037_cur."!cursor_pos"(rx1037_pos)
$P10 = rx1037_cur."ws"()
unless $P10, rx1037_fail
rx1037_pos = $P10."pos"()
# rx pass
rx1037_cur."!cursor_pass"(rx1037_pos, "arglist")
if_null rx1037_debug, debug_198
rx1037_cur."!cursor_debug"("PASS", "arglist", " at pos=", rx1037_pos)
debug_198:
.return (rx1037_cur)
rx1037_restart:
.annotate 'line', 3
if_null rx1037_debug, debug_199
rx1037_cur."!cursor_debug"("NEXT", "arglist")
debug_199:
rx1037_fail:
(rx1037_rep, rx1037_pos, $I10, $P10) = rx1037_cur."!mark_fail"(0)
lt rx1037_pos, -1, rx1037_done
eq rx1037_pos, -1, rx1037_fail
jump $I10
rx1037_done:
rx1037_cur."!cursor_fail"()
if_null rx1037_debug, debug_200
rx1037_cur."!cursor_debug"("FAIL", "arglist")
debug_200:
.return (rx1037_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__arglist" :subid("23_1308626176.8564") :method
.annotate 'line', 3
$P100 = self."!PREFIX__!subrule"("ws", "")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "TOP" :subid("24_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1042_tgt
.local int rx1042_pos
.local int rx1042_off
.local int rx1042_eos
.local int rx1042_rep
.local pmc rx1042_cur
.local pmc rx1042_debug
(rx1042_cur, rx1042_pos, rx1042_tgt, $I10) = self."!cursor_start"()
getattribute rx1042_debug, rx1042_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1042_cur
.local pmc match
.lex "$/", match
length rx1042_eos, rx1042_tgt
gt rx1042_pos, rx1042_eos, rx1042_done
set rx1042_off, 0
lt rx1042_pos, 2, rx1042_start
sub rx1042_off, rx1042_pos, 1
substr rx1042_tgt, rx1042_tgt, rx1042_off
rx1042_start:
eq $I10, 1, rx1042_restart
if_null rx1042_debug, debug_201
rx1042_cur."!cursor_debug"("START", "TOP")
debug_201:
$I10 = self.'from'()
ne $I10, -1, rxscan1044_done
goto rxscan1044_scan
rxscan1044_loop:
($P10) = rx1042_cur."from"()
inc $P10
set rx1042_pos, $P10
ge rx1042_pos, rx1042_eos, rxscan1044_done
rxscan1044_scan:
set_addr $I10, rxscan1044_loop
rx1042_cur."!mark_push"(0, rx1042_pos, $I10)
rxscan1044_done:
.annotate 'line', 25
# rx subrule "nibbler" subtype=capture negate=
rx1042_cur."!cursor_pos"(rx1042_pos)
$P10 = rx1042_cur."nibbler"()
unless $P10, rx1042_fail
rx1042_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("nibbler")
rx1042_pos = $P10."pos"()
alt1045_0:
.annotate 'line', 26
set_addr $I10, alt1045_1
rx1042_cur."!mark_push"(0, rx1042_pos, $I10)
# rxanchor eos
ne rx1042_pos, rx1042_eos, rx1042_fail
goto alt1045_end
alt1045_1:
# rx subrule "panic" subtype=method negate=
rx1042_cur."!cursor_pos"(rx1042_pos)
$P10 = rx1042_cur."panic"("Confused")
unless $P10, rx1042_fail
rx1042_pos = $P10."pos"()
alt1045_end:
.annotate 'line', 24
# rx pass
rx1042_cur."!cursor_pass"(rx1042_pos, "TOP")
if_null rx1042_debug, debug_202
rx1042_cur."!cursor_debug"("PASS", "TOP", " at pos=", rx1042_pos)
debug_202:
.return (rx1042_cur)
rx1042_restart:
.annotate 'line', 3
if_null rx1042_debug, debug_203
rx1042_cur."!cursor_debug"("NEXT", "TOP")
debug_203:
rx1042_fail:
(rx1042_rep, rx1042_pos, $I10, $P10) = rx1042_cur."!mark_fail"(0)
lt rx1042_pos, -1, rx1042_done
eq rx1042_pos, -1, rx1042_fail
jump $I10
rx1042_done:
rx1042_cur."!cursor_fail"()
if_null rx1042_debug, debug_204
rx1042_cur."!cursor_debug"("FAIL", "TOP")
debug_204:
.return (rx1042_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__TOP" :subid("25_1308626176.8564") :method
.annotate 'line', 3
$P100 = self."!PREFIX__!subrule"("nibbler", "")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "nibbler" :subid("26_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1047_tgt
.local int rx1047_pos
.local int rx1047_off
.local int rx1047_eos
.local int rx1047_rep
.local pmc rx1047_cur
.local pmc rx1047_debug
(rx1047_cur, rx1047_pos, rx1047_tgt, $I10) = self."!cursor_start"()
rx1047_cur."!cursor_caparray"("termconj")
getattribute rx1047_debug, rx1047_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1047_cur
.local pmc match
.lex "$/", match
length rx1047_eos, rx1047_tgt
gt rx1047_pos, rx1047_eos, rx1047_done
set rx1047_off, 0
lt rx1047_pos, 2, rx1047_start
sub rx1047_off, rx1047_pos, 1
substr rx1047_tgt, rx1047_tgt, rx1047_off
rx1047_start:
eq $I10, 1, rx1047_restart
if_null rx1047_debug, debug_205
rx1047_cur."!cursor_debug"("START", "nibbler")
debug_205:
$I10 = self.'from'()
ne $I10, -1, rxscan1049_done
goto rxscan1049_scan
rxscan1049_loop:
($P10) = rx1047_cur."from"()
inc $P10
set rx1047_pos, $P10
ge rx1047_pos, rx1047_eos, rxscan1049_done
rxscan1049_scan:
set_addr $I10, rxscan1049_loop
rx1047_cur."!mark_push"(0, rx1047_pos, $I10)
rxscan1049_done:
.annotate 'line', 30
# rx reduce name="nibbler" key="open"
rx1047_cur."!cursor_pos"(rx1047_pos)
rx1047_cur."!reduce"("nibbler", "open")
.annotate 'line', 31
# rx rxquantr1050 ** 0..1
set_addr $I10, rxquantr1050_done
rx1047_cur."!mark_push"(0, rx1047_pos, $I10)
rxquantr1050_loop:
# rx subrule "ws" subtype=method negate=
rx1047_cur."!cursor_pos"(rx1047_pos)
$P10 = rx1047_cur."ws"()
unless $P10, rx1047_fail
rx1047_pos = $P10."pos"()
alt1051_0:
set_addr $I10, alt1051_1
rx1047_cur."!mark_push"(0, rx1047_pos, $I10)
# rx literal "||"
add $I11, rx1047_pos, 2
gt $I11, rx1047_eos, rx1047_fail
sub $I11, rx1047_pos, rx1047_off
substr $S10, rx1047_tgt, $I11, 2
ne $S10, "||", rx1047_fail
add rx1047_pos, 2
goto alt1051_end
alt1051_1:
set_addr $I10, alt1051_2
rx1047_cur."!mark_push"(0, rx1047_pos, $I10)
# rx literal "|"
add $I11, rx1047_pos, 1
gt $I11, rx1047_eos, rx1047_fail
sub $I11, rx1047_pos, rx1047_off
ord $I11, rx1047_tgt, $I11
ne $I11, 124, rx1047_fail
add rx1047_pos, 1
goto alt1051_end
alt1051_2:
set_addr $I10, alt1051_3
rx1047_cur."!mark_push"(0, rx1047_pos, $I10)
# rx literal "&&"
add $I11, rx1047_pos, 2
gt $I11, rx1047_eos, rx1047_fail
sub $I11, rx1047_pos, rx1047_off
substr $S10, rx1047_tgt, $I11, 2
ne $S10, "&&", rx1047_fail
add rx1047_pos, 2
goto alt1051_end
alt1051_3:
# rx literal "&"
add $I11, rx1047_pos, 1
gt $I11, rx1047_eos, rx1047_fail
sub $I11, rx1047_pos, rx1047_off
ord $I11, rx1047_tgt, $I11
ne $I11, 38, rx1047_fail
add rx1047_pos, 1
alt1051_end:
set_addr $I10, rxquantr1050_done
(rx1047_rep) = rx1047_cur."!mark_commit"($I10)
rxquantr1050_done:
.annotate 'line', 32
# rx subrule "termconj" subtype=capture negate=
rx1047_cur."!cursor_pos"(rx1047_pos)
$P10 = rx1047_cur."termconj"()
unless $P10, rx1047_fail
rx1047_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("termconj")
rx1047_pos = $P10."pos"()
.annotate 'line', 35
# rx rxquantr1052 ** 0..*
set_addr $I10, rxquantr1052_done
rx1047_cur."!mark_push"(0, rx1047_pos, $I10)
rxquantr1052_loop:
alt1053_0:
.annotate 'line', 33
set_addr $I10, alt1053_1
rx1047_cur."!mark_push"(0, rx1047_pos, $I10)
# rx literal "||"
add $I11, rx1047_pos, 2
gt $I11, rx1047_eos, rx1047_fail
sub $I11, rx1047_pos, rx1047_off
substr $S10, rx1047_tgt, $I11, 2
ne $S10, "||", rx1047_fail
add rx1047_pos, 2
goto alt1053_end
alt1053_1:
# rx literal "|"
add $I11, rx1047_pos, 1
gt $I11, rx1047_eos, rx1047_fail
sub $I11, rx1047_pos, rx1047_off
ord $I11, rx1047_tgt, $I11
ne $I11, 124, rx1047_fail
add rx1047_pos, 1
alt1053_end:
alt1054_0:
.annotate 'line', 34
set_addr $I10, alt1054_1
rx1047_cur."!mark_push"(0, rx1047_pos, $I10)
# rx subrule "termconj" subtype=capture negate=
rx1047_cur."!cursor_pos"(rx1047_pos)
$P10 = rx1047_cur."termconj"()
unless $P10, rx1047_fail
rx1047_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("termconj")
rx1047_pos = $P10."pos"()
goto alt1054_end
alt1054_1:
# rx subrule "panic" subtype=method negate=
rx1047_cur."!cursor_pos"(rx1047_pos)
$P10 = rx1047_cur."panic"("Null pattern not allowed")
unless $P10, rx1047_fail
rx1047_pos = $P10."pos"()
alt1054_end:
.annotate 'line', 35
set_addr $I10, rxquantr1052_done
(rx1047_rep) = rx1047_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1052_done
rx1047_cur."!mark_push"(rx1047_rep, rx1047_pos, $I10)
goto rxquantr1052_loop
rxquantr1052_done:
.annotate 'line', 29
# rx pass
rx1047_cur."!cursor_pass"(rx1047_pos, "nibbler")
if_null rx1047_debug, debug_206
rx1047_cur."!cursor_debug"("PASS", "nibbler", " at pos=", rx1047_pos)
debug_206:
.return (rx1047_cur)
rx1047_restart:
.annotate 'line', 3
if_null rx1047_debug, debug_207
rx1047_cur."!cursor_debug"("NEXT", "nibbler")
debug_207:
rx1047_fail:
(rx1047_rep, rx1047_pos, $I10, $P10) = rx1047_cur."!mark_fail"(0)
lt rx1047_pos, -1, rx1047_done
eq rx1047_pos, -1, rx1047_fail
jump $I10
rx1047_done:
rx1047_cur."!cursor_fail"()
if_null rx1047_debug, debug_208
rx1047_cur."!cursor_debug"("FAIL", "nibbler")
debug_208:
.return (rx1047_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__nibbler" :subid("27_1308626176.8564") :method
.annotate 'line', 3
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "termconj" :subid("28_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1056_tgt
.local int rx1056_pos
.local int rx1056_off
.local int rx1056_eos
.local int rx1056_rep
.local pmc rx1056_cur
.local pmc rx1056_debug
(rx1056_cur, rx1056_pos, rx1056_tgt, $I10) = self."!cursor_start"()
rx1056_cur."!cursor_caparray"("termish")
getattribute rx1056_debug, rx1056_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1056_cur
.local pmc match
.lex "$/", match
length rx1056_eos, rx1056_tgt
gt rx1056_pos, rx1056_eos, rx1056_done
set rx1056_off, 0
lt rx1056_pos, 2, rx1056_start
sub rx1056_off, rx1056_pos, 1
substr rx1056_tgt, rx1056_tgt, rx1056_off
rx1056_start:
eq $I10, 1, rx1056_restart
if_null rx1056_debug, debug_209
rx1056_cur."!cursor_debug"("START", "termconj")
debug_209:
$I10 = self.'from'()
ne $I10, -1, rxscan1058_done
goto rxscan1058_scan
rxscan1058_loop:
($P10) = rx1056_cur."from"()
inc $P10
set rx1056_pos, $P10
ge rx1056_pos, rx1056_eos, rxscan1058_done
rxscan1058_scan:
set_addr $I10, rxscan1058_loop
rx1056_cur."!mark_push"(0, rx1056_pos, $I10)
rxscan1058_done:
.annotate 'line', 39
# rx subrule "termish" subtype=capture negate=
rx1056_cur."!cursor_pos"(rx1056_pos)
$P10 = rx1056_cur."termish"()
unless $P10, rx1056_fail
rx1056_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("termish")
rx1056_pos = $P10."pos"()
.annotate 'line', 42
# rx rxquantr1059 ** 0..*
set_addr $I10, rxquantr1059_done
rx1056_cur."!mark_push"(0, rx1056_pos, $I10)
rxquantr1059_loop:
alt1060_0:
.annotate 'line', 40
set_addr $I10, alt1060_1
rx1056_cur."!mark_push"(0, rx1056_pos, $I10)
# rx literal "&&"
add $I11, rx1056_pos, 2
gt $I11, rx1056_eos, rx1056_fail
sub $I11, rx1056_pos, rx1056_off
substr $S10, rx1056_tgt, $I11, 2
ne $S10, "&&", rx1056_fail
add rx1056_pos, 2
goto alt1060_end
alt1060_1:
# rx literal "&"
add $I11, rx1056_pos, 1
gt $I11, rx1056_eos, rx1056_fail
sub $I11, rx1056_pos, rx1056_off
ord $I11, rx1056_tgt, $I11
ne $I11, 38, rx1056_fail
add rx1056_pos, 1
alt1060_end:
alt1061_0:
.annotate 'line', 41
set_addr $I10, alt1061_1
rx1056_cur."!mark_push"(0, rx1056_pos, $I10)
# rx subrule "termish" subtype=capture negate=
rx1056_cur."!cursor_pos"(rx1056_pos)
$P10 = rx1056_cur."termish"()
unless $P10, rx1056_fail
rx1056_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("termish")
rx1056_pos = $P10."pos"()
goto alt1061_end
alt1061_1:
# rx subrule "panic" subtype=method negate=
rx1056_cur."!cursor_pos"(rx1056_pos)
$P10 = rx1056_cur."panic"("Null pattern not allowed")
unless $P10, rx1056_fail
rx1056_pos = $P10."pos"()
alt1061_end:
.annotate 'line', 42
set_addr $I10, rxquantr1059_done
(rx1056_rep) = rx1056_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1059_done
rx1056_cur."!mark_push"(rx1056_rep, rx1056_pos, $I10)
goto rxquantr1059_loop
rxquantr1059_done:
.annotate 'line', 38
# rx pass
rx1056_cur."!cursor_pass"(rx1056_pos, "termconj")
if_null rx1056_debug, debug_210
rx1056_cur."!cursor_debug"("PASS", "termconj", " at pos=", rx1056_pos)
debug_210:
.return (rx1056_cur)
rx1056_restart:
.annotate 'line', 3
if_null rx1056_debug, debug_211
rx1056_cur."!cursor_debug"("NEXT", "termconj")
debug_211:
rx1056_fail:
(rx1056_rep, rx1056_pos, $I10, $P10) = rx1056_cur."!mark_fail"(0)
lt rx1056_pos, -1, rx1056_done
eq rx1056_pos, -1, rx1056_fail
jump $I10
rx1056_done:
rx1056_cur."!cursor_fail"()
if_null rx1056_debug, debug_212
rx1056_cur."!cursor_debug"("FAIL", "termconj")
debug_212:
.return (rx1056_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__termconj" :subid("29_1308626176.8564") :method
.annotate 'line', 3
$P100 = self."!PREFIX__!subrule"("termish", "")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "termish" :subid("30_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1063_tgt
.local int rx1063_pos
.local int rx1063_off
.local int rx1063_eos
.local int rx1063_rep
.local pmc rx1063_cur
.local pmc rx1063_debug
(rx1063_cur, rx1063_pos, rx1063_tgt, $I10) = self."!cursor_start"()
rx1063_cur."!cursor_caparray"("noun")
getattribute rx1063_debug, rx1063_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1063_cur
.local pmc match
.lex "$/", match
length rx1063_eos, rx1063_tgt
gt rx1063_pos, rx1063_eos, rx1063_done
set rx1063_off, 0
lt rx1063_pos, 2, rx1063_start
sub rx1063_off, rx1063_pos, 1
substr rx1063_tgt, rx1063_tgt, rx1063_off
rx1063_start:
eq $I10, 1, rx1063_restart
if_null rx1063_debug, debug_213
rx1063_cur."!cursor_debug"("START", "termish")
debug_213:
$I10 = self.'from'()
ne $I10, -1, rxscan1065_done
goto rxscan1065_scan
rxscan1065_loop:
($P10) = rx1063_cur."from"()
inc $P10
set rx1063_pos, $P10
ge rx1063_pos, rx1063_eos, rxscan1065_done
rxscan1065_scan:
set_addr $I10, rxscan1065_loop
rx1063_cur."!mark_push"(0, rx1063_pos, $I10)
rxscan1065_done:
.annotate 'line', 46
# rx rxquantr1066 ** 1..*
set_addr $I10, rxquantr1066_done
rx1063_cur."!mark_push"(0, -1, $I10)
rxquantr1066_loop:
# rx subrule "quantified_atom" subtype=capture negate=
rx1063_cur."!cursor_pos"(rx1063_pos)
$P10 = rx1063_cur."quantified_atom"()
unless $P10, rx1063_fail
goto rxsubrule1067_pass
rxsubrule1067_back:
$P10 = $P10."!cursor_next"()
unless $P10, rx1063_fail
rxsubrule1067_pass:
set_addr $I10, rxsubrule1067_back
rx1063_cur."!mark_push"(0, rx1063_pos, $I10, $P10)
$P10."!cursor_names"("noun")
rx1063_pos = $P10."pos"()
set_addr $I10, rxquantr1066_done
(rx1063_rep) = rx1063_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1066_done
rx1063_cur."!mark_push"(rx1063_rep, rx1063_pos, $I10)
goto rxquantr1066_loop
rxquantr1066_done:
.annotate 'line', 45
# rx pass
rx1063_cur."!cursor_pass"(rx1063_pos, "termish")
if_null rx1063_debug, debug_214
rx1063_cur."!cursor_debug"("PASS", "termish", " at pos=", rx1063_pos)
debug_214:
.return (rx1063_cur)
rx1063_restart:
.annotate 'line', 3
if_null rx1063_debug, debug_215
rx1063_cur."!cursor_debug"("NEXT", "termish")
debug_215:
rx1063_fail:
(rx1063_rep, rx1063_pos, $I10, $P10) = rx1063_cur."!mark_fail"(0)
lt rx1063_pos, -1, rx1063_done
eq rx1063_pos, -1, rx1063_fail
jump $I10
rx1063_done:
rx1063_cur."!cursor_fail"()
if_null rx1063_debug, debug_216
rx1063_cur."!cursor_debug"("FAIL", "termish")
debug_216:
.return (rx1063_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__termish" :subid("31_1308626176.8564") :method
.annotate 'line', 3
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "quantified_atom" :subid("32_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.const 'Sub' $P1075 = "34_1308626176.8564"
capture_lex $P1075
.local string rx1069_tgt
.local int rx1069_pos
.local int rx1069_off
.local int rx1069_eos
.local int rx1069_rep
.local pmc rx1069_cur
.local pmc rx1069_debug
(rx1069_cur, rx1069_pos, rx1069_tgt, $I10) = self."!cursor_start"()
rx1069_cur."!cursor_caparray"("quantifier", "backmod")
getattribute rx1069_debug, rx1069_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1069_cur
.local pmc match
.lex "$/", match
length rx1069_eos, rx1069_tgt
gt rx1069_pos, rx1069_eos, rx1069_done
set rx1069_off, 0
lt rx1069_pos, 2, rx1069_start
sub rx1069_off, rx1069_pos, 1
substr rx1069_tgt, rx1069_tgt, rx1069_off
rx1069_start:
eq $I10, 1, rx1069_restart
if_null rx1069_debug, debug_217
rx1069_cur."!cursor_debug"("START", "quantified_atom")
debug_217:
$I10 = self.'from'()
ne $I10, -1, rxscan1071_done
goto rxscan1071_scan
rxscan1071_loop:
($P10) = rx1069_cur."from"()
inc $P10
set rx1069_pos, $P10
ge rx1069_pos, rx1069_eos, rxscan1071_done
rxscan1071_scan:
set_addr $I10, rxscan1071_loop
rx1069_cur."!mark_push"(0, rx1069_pos, $I10)
rxscan1071_done:
.annotate 'line', 50
# rx subrule "atom" subtype=capture negate=
rx1069_cur."!cursor_pos"(rx1069_pos)
$P10 = rx1069_cur."atom"()
unless $P10, rx1069_fail
rx1069_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("atom")
rx1069_pos = $P10."pos"()
# rx rxquantr1072 ** 0..1
set_addr $I10, rxquantr1072_done
rx1069_cur."!mark_push"(0, rx1069_pos, $I10)
rxquantr1072_loop:
# rx subrule "ws" subtype=method negate=
rx1069_cur."!cursor_pos"(rx1069_pos)
$P10 = rx1069_cur."ws"()
unless $P10, rx1069_fail
rx1069_pos = $P10."pos"()
alt1073_0:
set_addr $I10, alt1073_1
rx1069_cur."!mark_push"(0, rx1069_pos, $I10)
# rx subrule "quantifier" subtype=capture negate=
rx1069_cur."!cursor_pos"(rx1069_pos)
$P10 = rx1069_cur."quantifier"()
unless $P10, rx1069_fail
rx1069_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("quantifier")
rx1069_pos = $P10."pos"()
goto alt1073_end
alt1073_1:
# rx subrule "before" subtype=zerowidth negate=
rx1069_cur."!cursor_pos"(rx1069_pos)
.const 'Sub' $P1075 = "34_1308626176.8564"
capture_lex $P1075
$P10 = rx1069_cur."before"($P1075)
unless $P10, rx1069_fail
# rx subrule "backmod" subtype=capture negate=
rx1069_cur."!cursor_pos"(rx1069_pos)
$P10 = rx1069_cur."backmod"()
unless $P10, rx1069_fail
rx1069_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("backmod")
rx1069_pos = $P10."pos"()
# rx subrule "alpha" subtype=zerowidth negate=1
rx1069_cur."!cursor_pos"(rx1069_pos)
$P10 = rx1069_cur."alpha"()
if $P10, rx1069_fail
alt1073_end:
set_addr $I10, rxquantr1072_done
(rx1069_rep) = rx1069_cur."!mark_commit"($I10)
rxquantr1072_done:
.annotate 'line', 49
# rx pass
rx1069_cur."!cursor_pass"(rx1069_pos, "quantified_atom")
if_null rx1069_debug, debug_222
rx1069_cur."!cursor_debug"("PASS", "quantified_atom", " at pos=", rx1069_pos)
debug_222:
.return (rx1069_cur)
rx1069_restart:
.annotate 'line', 3
if_null rx1069_debug, debug_223
rx1069_cur."!cursor_debug"("NEXT", "quantified_atom")
debug_223:
rx1069_fail:
(rx1069_rep, rx1069_pos, $I10, $P10) = rx1069_cur."!mark_fail"(0)
lt rx1069_pos, -1, rx1069_done
eq rx1069_pos, -1, rx1069_fail
jump $I10
rx1069_done:
rx1069_cur."!cursor_fail"()
if_null rx1069_debug, debug_224
rx1069_cur."!cursor_debug"("FAIL", "quantified_atom")
debug_224:
.return (rx1069_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__quantified_atom" :subid("33_1308626176.8564") :method
.annotate 'line', 3
$P100 = self."!PREFIX__!subrule"("atom", "")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "_block1074" :anon :subid("34_1308626176.8564") :method :outer("32_1308626176.8564")
.annotate 'line', 50
.local string rx1076_tgt
.local int rx1076_pos
.local int rx1076_off
.local int rx1076_eos
.local int rx1076_rep
.local pmc rx1076_cur
.local pmc rx1076_debug
(rx1076_cur, rx1076_pos, rx1076_tgt, $I10) = self."!cursor_start"()
getattribute rx1076_debug, rx1076_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1076_cur
.local pmc match
.lex "$/", match
length rx1076_eos, rx1076_tgt
gt rx1076_pos, rx1076_eos, rx1076_done
set rx1076_off, 0
lt rx1076_pos, 2, rx1076_start
sub rx1076_off, rx1076_pos, 1
substr rx1076_tgt, rx1076_tgt, rx1076_off
rx1076_start:
eq $I10, 1, rx1076_restart
if_null rx1076_debug, debug_218
rx1076_cur."!cursor_debug"("START", "")
debug_218:
$I10 = self.'from'()
ne $I10, -1, rxscan1077_done
goto rxscan1077_scan
rxscan1077_loop:
($P10) = rx1076_cur."from"()
inc $P10
set rx1076_pos, $P10
ge rx1076_pos, rx1076_eos, rxscan1077_done
rxscan1077_scan:
set_addr $I10, rxscan1077_loop
rx1076_cur."!mark_push"(0, rx1076_pos, $I10)
rxscan1077_done:
# rx literal ":"
add $I11, rx1076_pos, 1
gt $I11, rx1076_eos, rx1076_fail
sub $I11, rx1076_pos, rx1076_off
ord $I11, rx1076_tgt, $I11
ne $I11, 58, rx1076_fail
add rx1076_pos, 1
# rx pass
rx1076_cur."!cursor_pass"(rx1076_pos, "")
if_null rx1076_debug, debug_219
rx1076_cur."!cursor_debug"("PASS", "", " at pos=", rx1076_pos)
debug_219:
.return (rx1076_cur)
rx1076_restart:
if_null rx1076_debug, debug_220
rx1076_cur."!cursor_debug"("NEXT", "")
debug_220:
rx1076_fail:
(rx1076_rep, rx1076_pos, $I10, $P10) = rx1076_cur."!mark_fail"(0)
lt rx1076_pos, -1, rx1076_done
eq rx1076_pos, -1, rx1076_fail
jump $I10
rx1076_done:
rx1076_cur."!cursor_fail"()
if_null rx1076_debug, debug_221
rx1076_cur."!cursor_debug"("FAIL", "")
debug_221:
.return (rx1076_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "atom" :subid("35_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.const 'Sub' $P1086 = "37_1308626176.8564"
capture_lex $P1086
.local string rx1079_tgt
.local int rx1079_pos
.local int rx1079_off
.local int rx1079_eos
.local int rx1079_rep
.local pmc rx1079_cur
.local pmc rx1079_debug
(rx1079_cur, rx1079_pos, rx1079_tgt, $I10) = self."!cursor_start"()
getattribute rx1079_debug, rx1079_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1079_cur
.local pmc match
.lex "$/", match
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:
eq $I10, 1, rx1079_restart
if_null rx1079_debug, debug_225
rx1079_cur."!cursor_debug"("START", "atom")
debug_225:
$I10 = self.'from'()
ne $I10, -1, rxscan1081_done
goto rxscan1081_scan
rxscan1081_loop:
($P10) = rx1079_cur."from"()
inc $P10
set rx1079_pos, $P10
ge rx1079_pos, rx1079_eos, rxscan1081_done
rxscan1081_scan:
set_addr $I10, rxscan1081_loop
rx1079_cur."!mark_push"(0, rx1079_pos, $I10)
rxscan1081_done:
alt1082_0:
.annotate 'line', 55
set_addr $I10, alt1082_1
rx1079_cur."!mark_push"(0, rx1079_pos, $I10)
.annotate 'line', 56
# rx charclass w
ge rx1079_pos, rx1079_eos, rx1079_fail
sub $I10, rx1079_pos, rx1079_off
is_cclass $I11, 8192, rx1079_tgt, $I10
unless $I11, rx1079_fail
inc rx1079_pos
# rx rxquantr1083 ** 0..1
set_addr $I10, rxquantr1083_done
rx1079_cur."!mark_push"(0, rx1079_pos, $I10)
rxquantr1083_loop:
# rx rxquantg1084 ** 1..*
rxquantg1084_loop:
# rx charclass w
ge rx1079_pos, rx1079_eos, rx1079_fail
sub $I10, rx1079_pos, rx1079_off
is_cclass $I11, 8192, rx1079_tgt, $I10
unless $I11, rx1079_fail
inc rx1079_pos
set_addr $I10, rxquantg1084_done
rx1079_cur."!mark_push"(rx1079_rep, rx1079_pos, $I10)
goto rxquantg1084_loop
rxquantg1084_done:
# rx subrule "before" subtype=zerowidth negate=
rx1079_cur."!cursor_pos"(rx1079_pos)
.const 'Sub' $P1086 = "37_1308626176.8564"
capture_lex $P1086
$P10 = rx1079_cur."before"($P1086)
unless $P10, rx1079_fail
set_addr $I10, rxquantr1083_done
(rx1079_rep) = rx1079_cur."!mark_commit"($I10)
rxquantr1083_done:
goto alt1082_end
alt1082_1:
.annotate 'line', 57
# rx subrule "metachar" subtype=capture negate=
rx1079_cur."!cursor_pos"(rx1079_pos)
$P10 = rx1079_cur."metachar"()
unless $P10, rx1079_fail
rx1079_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("metachar")
rx1079_pos = $P10."pos"()
alt1082_end:
.annotate 'line', 53
# rx pass
rx1079_cur."!cursor_pass"(rx1079_pos, "atom")
if_null rx1079_debug, debug_230
rx1079_cur."!cursor_debug"("PASS", "atom", " at pos=", rx1079_pos)
debug_230:
.return (rx1079_cur)
rx1079_restart:
.annotate 'line', 3
if_null rx1079_debug, debug_231
rx1079_cur."!cursor_debug"("NEXT", "atom")
debug_231:
rx1079_fail:
(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
rx1079_done:
rx1079_cur."!cursor_fail"()
if_null rx1079_debug, debug_232
rx1079_cur."!cursor_debug"("FAIL", "atom")
debug_232:
.return (rx1079_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__atom" :subid("36_1308626176.8564") :method
.annotate 'line', 3
$P100 = self."!PREFIX__!subrule"("metachar", "")
new $P101, "ResizablePMCArray"
push $P101, $P100
push $P101, ""
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "_block1085" :anon :subid("37_1308626176.8564") :method :outer("35_1308626176.8564")
.annotate 'line', 56
.local string rx1087_tgt
.local int rx1087_pos
.local int rx1087_off
.local int rx1087_eos
.local int rx1087_rep
.local pmc rx1087_cur
.local pmc rx1087_debug
(rx1087_cur, rx1087_pos, rx1087_tgt, $I10) = self."!cursor_start"()
getattribute rx1087_debug, rx1087_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1087_cur
.local pmc match
.lex "$/", match
length rx1087_eos, rx1087_tgt
gt rx1087_pos, rx1087_eos, rx1087_done
set rx1087_off, 0
lt rx1087_pos, 2, rx1087_start
sub rx1087_off, rx1087_pos, 1
substr rx1087_tgt, rx1087_tgt, rx1087_off
rx1087_start:
eq $I10, 1, rx1087_restart
if_null rx1087_debug, debug_226
rx1087_cur."!cursor_debug"("START", "")
debug_226:
$I10 = self.'from'()
ne $I10, -1, rxscan1088_done
goto rxscan1088_scan
rxscan1088_loop:
($P10) = rx1087_cur."from"()
inc $P10
set rx1087_pos, $P10
ge rx1087_pos, rx1087_eos, rxscan1088_done
rxscan1088_scan:
set_addr $I10, rxscan1088_loop
rx1087_cur."!mark_push"(0, rx1087_pos, $I10)
rxscan1088_done:
# rx charclass w
ge rx1087_pos, rx1087_eos, rx1087_fail
sub $I10, rx1087_pos, rx1087_off
is_cclass $I11, 8192, rx1087_tgt, $I10
unless $I11, rx1087_fail
inc rx1087_pos
# rx pass
rx1087_cur."!cursor_pass"(rx1087_pos, "")
if_null rx1087_debug, debug_227
rx1087_cur."!cursor_debug"("PASS", "", " at pos=", rx1087_pos)
debug_227:
.return (rx1087_cur)
rx1087_restart:
if_null rx1087_debug, debug_228
rx1087_cur."!cursor_debug"("NEXT", "")
debug_228:
rx1087_fail:
(rx1087_rep, rx1087_pos, $I10, $P10) = rx1087_cur."!mark_fail"(0)
lt rx1087_pos, -1, rx1087_done
eq rx1087_pos, -1, rx1087_fail
jump $I10
rx1087_done:
rx1087_cur."!cursor_fail"()
if_null rx1087_debug, debug_229
rx1087_cur."!cursor_debug"("FAIL", "")
debug_229:
.return (rx1087_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "quantifier" :subid("38_1308626176.8564") :method
.annotate 'line', 61
$P100 = self."!protoregex"("quantifier")
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__quantifier" :subid("39_1308626176.8564") :method
.annotate 'line', 61
$P101 = self."!PREFIX__!protoregex"("quantifier")
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "quantifier:sym<*>" :subid("40_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1092_tgt
.local int rx1092_pos
.local int rx1092_off
.local int rx1092_eos
.local int rx1092_rep
.local pmc rx1092_cur
.local pmc rx1092_debug
(rx1092_cur, rx1092_pos, rx1092_tgt, $I10) = self."!cursor_start"()
getattribute rx1092_debug, rx1092_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1092_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:
eq $I10, 1, rx1092_restart
if_null rx1092_debug, debug_233
rx1092_cur."!cursor_debug"("START", "quantifier:sym<*>")
debug_233:
$I10 = self.'from'()
ne $I10, -1, rxscan1094_done
goto rxscan1094_scan
rxscan1094_loop:
($P10) = rx1092_cur."from"()
inc $P10
set rx1092_pos, $P10
ge rx1092_pos, rx1092_eos, rxscan1094_done
rxscan1094_scan:
set_addr $I10, rxscan1094_loop
rx1092_cur."!mark_push"(0, rx1092_pos, $I10)
rxscan1094_done:
.annotate 'line', 62
# rx subcapture "sym"
set_addr $I10, rxcap_1095_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
ord $I11, rx1092_tgt, $I11
ne $I11, 42, rx1092_fail
add rx1092_pos, 1
set_addr $I10, rxcap_1095_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)
$P10."!cursor_names"("sym")
goto rxcap_1095_done
rxcap_1095_fail:
goto rx1092_fail
rxcap_1095_done:
# rx subrule "backmod" subtype=capture negate=
rx1092_cur."!cursor_pos"(rx1092_pos)
$P10 = rx1092_cur."backmod"()
unless $P10, rx1092_fail
rx1092_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("backmod")
rx1092_pos = $P10."pos"()
# rx pass
rx1092_cur."!cursor_pass"(rx1092_pos, "quantifier:sym<*>")
if_null rx1092_debug, debug_234
rx1092_cur."!cursor_debug"("PASS", "quantifier:sym<*>", " at pos=", rx1092_pos)
debug_234:
.return (rx1092_cur)
rx1092_restart:
.annotate 'line', 3
if_null rx1092_debug, debug_235
rx1092_cur."!cursor_debug"("NEXT", "quantifier:sym<*>")
debug_235:
rx1092_fail:
(rx1092_rep, rx1092_pos, $I10, $P10) = rx1092_cur."!mark_fail"(0)
lt rx1092_pos, -1, rx1092_done
eq rx1092_pos, -1, rx1092_fail
jump $I10
rx1092_done:
rx1092_cur."!cursor_fail"()
if_null rx1092_debug, debug_236
rx1092_cur."!cursor_debug"("FAIL", "quantifier:sym<*>")
debug_236:
.return (rx1092_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__quantifier:sym<*>" :subid("41_1308626176.8564") :method
.annotate 'line', 3
$P100 = self."!PREFIX__!subrule"("backmod", "*")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "quantifier:sym<+>" :subid("42_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1097_tgt
.local int rx1097_pos
.local int rx1097_off
.local int rx1097_eos
.local int rx1097_rep
.local pmc rx1097_cur
.local pmc rx1097_debug
(rx1097_cur, rx1097_pos, rx1097_tgt, $I10) = self."!cursor_start"()
getattribute rx1097_debug, rx1097_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1097_cur
.local pmc match
.lex "$/", match
length rx1097_eos, rx1097_tgt
gt rx1097_pos, rx1097_eos, rx1097_done
set rx1097_off, 0
lt rx1097_pos, 2, rx1097_start
sub rx1097_off, rx1097_pos, 1
substr rx1097_tgt, rx1097_tgt, rx1097_off
rx1097_start:
eq $I10, 1, rx1097_restart
if_null rx1097_debug, debug_237
rx1097_cur."!cursor_debug"("START", "quantifier:sym<+>")
debug_237:
$I10 = self.'from'()
ne $I10, -1, rxscan1099_done
goto rxscan1099_scan
rxscan1099_loop:
($P10) = rx1097_cur."from"()
inc $P10
set rx1097_pos, $P10
ge rx1097_pos, rx1097_eos, rxscan1099_done
rxscan1099_scan:
set_addr $I10, rxscan1099_loop
rx1097_cur."!mark_push"(0, rx1097_pos, $I10)
rxscan1099_done:
.annotate 'line', 63
# rx subcapture "sym"
set_addr $I10, rxcap_1100_fail
rx1097_cur."!mark_push"(0, rx1097_pos, $I10)
# rx literal "+"
add $I11, rx1097_pos, 1
gt $I11, rx1097_eos, rx1097_fail
sub $I11, rx1097_pos, rx1097_off
ord $I11, rx1097_tgt, $I11
ne $I11, 43, rx1097_fail
add rx1097_pos, 1
set_addr $I10, rxcap_1100_fail
($I12, $I11) = rx1097_cur."!mark_peek"($I10)
rx1097_cur."!cursor_pos"($I11)
($P10) = rx1097_cur."!cursor_start"()
$P10."!cursor_pass"(rx1097_pos, "")
rx1097_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("sym")
goto rxcap_1100_done
rxcap_1100_fail:
goto rx1097_fail
rxcap_1100_done:
# rx subrule "backmod" subtype=capture negate=
rx1097_cur."!cursor_pos"(rx1097_pos)
$P10 = rx1097_cur."backmod"()
unless $P10, rx1097_fail
rx1097_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("backmod")
rx1097_pos = $P10."pos"()
# rx pass
rx1097_cur."!cursor_pass"(rx1097_pos, "quantifier:sym<+>")
if_null rx1097_debug, debug_238
rx1097_cur."!cursor_debug"("PASS", "quantifier:sym<+>", " at pos=", rx1097_pos)
debug_238:
.return (rx1097_cur)
rx1097_restart:
.annotate 'line', 3
if_null rx1097_debug, debug_239
rx1097_cur."!cursor_debug"("NEXT", "quantifier:sym<+>")
debug_239:
rx1097_fail:
(rx1097_rep, rx1097_pos, $I10, $P10) = rx1097_cur."!mark_fail"(0)
lt rx1097_pos, -1, rx1097_done
eq rx1097_pos, -1, rx1097_fail
jump $I10
rx1097_done:
rx1097_cur."!cursor_fail"()
if_null rx1097_debug, debug_240
rx1097_cur."!cursor_debug"("FAIL", "quantifier:sym<+>")
debug_240:
.return (rx1097_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__quantifier:sym<+>" :subid("43_1308626176.8564") :method
.annotate 'line', 3
$P100 = self."!PREFIX__!subrule"("backmod", "+")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "quantifier:sym<?>" :subid("44_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1102_tgt
.local int rx1102_pos
.local int rx1102_off
.local int rx1102_eos
.local int rx1102_rep
.local pmc rx1102_cur
.local pmc rx1102_debug
(rx1102_cur, rx1102_pos, rx1102_tgt, $I10) = self."!cursor_start"()
getattribute rx1102_debug, rx1102_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1102_cur
.local pmc match
.lex "$/", match
length rx1102_eos, rx1102_tgt
gt rx1102_pos, rx1102_eos, rx1102_done
set rx1102_off, 0
lt rx1102_pos, 2, rx1102_start
sub rx1102_off, rx1102_pos, 1
substr rx1102_tgt, rx1102_tgt, rx1102_off
rx1102_start:
eq $I10, 1, rx1102_restart
if_null rx1102_debug, debug_241
rx1102_cur."!cursor_debug"("START", "quantifier:sym<?>")
debug_241:
$I10 = self.'from'()
ne $I10, -1, rxscan1104_done
goto rxscan1104_scan
rxscan1104_loop:
($P10) = rx1102_cur."from"()
inc $P10
set rx1102_pos, $P10
ge rx1102_pos, rx1102_eos, rxscan1104_done
rxscan1104_scan:
set_addr $I10, rxscan1104_loop
rx1102_cur."!mark_push"(0, rx1102_pos, $I10)
rxscan1104_done:
.annotate 'line', 64
# rx subcapture "sym"
set_addr $I10, rxcap_1105_fail
rx1102_cur."!mark_push"(0, rx1102_pos, $I10)
# rx literal "?"
add $I11, rx1102_pos, 1
gt $I11, rx1102_eos, rx1102_fail
sub $I11, rx1102_pos, rx1102_off
ord $I11, rx1102_tgt, $I11
ne $I11, 63, rx1102_fail
add rx1102_pos, 1
set_addr $I10, rxcap_1105_fail
($I12, $I11) = rx1102_cur."!mark_peek"($I10)
rx1102_cur."!cursor_pos"($I11)
($P10) = rx1102_cur."!cursor_start"()
$P10."!cursor_pass"(rx1102_pos, "")
rx1102_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("sym")
goto rxcap_1105_done
rxcap_1105_fail:
goto rx1102_fail
rxcap_1105_done:
# rx subrule "backmod" subtype=capture negate=
rx1102_cur."!cursor_pos"(rx1102_pos)
$P10 = rx1102_cur."backmod"()
unless $P10, rx1102_fail
rx1102_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("backmod")
rx1102_pos = $P10."pos"()
# rx pass
rx1102_cur."!cursor_pass"(rx1102_pos, "quantifier:sym<?>")
if_null rx1102_debug, debug_242
rx1102_cur."!cursor_debug"("PASS", "quantifier:sym<?>", " at pos=", rx1102_pos)
debug_242:
.return (rx1102_cur)
rx1102_restart:
.annotate 'line', 3
if_null rx1102_debug, debug_243
rx1102_cur."!cursor_debug"("NEXT", "quantifier:sym<?>")
debug_243:
rx1102_fail:
(rx1102_rep, rx1102_pos, $I10, $P10) = rx1102_cur."!mark_fail"(0)
lt rx1102_pos, -1, rx1102_done
eq rx1102_pos, -1, rx1102_fail
jump $I10
rx1102_done:
rx1102_cur."!cursor_fail"()
if_null rx1102_debug, debug_244
rx1102_cur."!cursor_debug"("FAIL", "quantifier:sym<?>")
debug_244:
.return (rx1102_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__quantifier:sym<?>" :subid("45_1308626176.8564") :method
.annotate 'line', 3
$P100 = self."!PREFIX__!subrule"("backmod", "?")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "quantifier:sym<{N,M}>" :subid("46_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.const 'Sub' $P1122 = "51_1308626176.8564"
capture_lex $P1122
.const 'Sub' $P1117 = "50_1308626176.8564"
capture_lex $P1117
.const 'Sub' $P1113 = "49_1308626176.8564"
capture_lex $P1113
.const 'Sub' $P1111 = "48_1308626176.8564"
capture_lex $P1111
.local string rx1107_tgt
.local int rx1107_pos
.local int rx1107_off
.local int rx1107_eos
.local int rx1107_rep
.local pmc rx1107_cur
.local pmc rx1107_debug
(rx1107_cur, rx1107_pos, rx1107_tgt, $I10) = self."!cursor_start"()
getattribute rx1107_debug, rx1107_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1107_cur
.local pmc match
.lex "$/", match
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:
eq $I10, 1, rx1107_restart
if_null rx1107_debug, debug_245
rx1107_cur."!cursor_debug"("START", "quantifier:sym<{N,M}>")
debug_245:
$I10 = self.'from'()
ne $I10, -1, rxscan1109_done
goto rxscan1109_scan
rxscan1109_loop:
($P10) = rx1107_cur."from"()
inc $P10
set rx1107_pos, $P10
ge rx1107_pos, rx1107_eos, rxscan1109_done
rxscan1109_scan:
set_addr $I10, rxscan1109_loop
rx1107_cur."!mark_push"(0, rx1107_pos, $I10)
rxscan1109_done:
.annotate 'line', 65
rx1107_cur."!cursor_pos"(rx1107_pos)
find_lex $P101, unicode:"$\x{a2}"
$P102 = $P101."MATCH"()
store_lex "$/", $P102
.const 'Sub' $P1111 = "48_1308626176.8564"
capture_lex $P1111
$P103 = $P1111()
# rx literal "{"
add $I11, rx1107_pos, 1
gt $I11, rx1107_eos, rx1107_fail
sub $I11, rx1107_pos, rx1107_off
ord $I11, rx1107_tgt, $I11
ne $I11, 123, rx1107_fail
add rx1107_pos, 1
# rx subrule $P1113 subtype=capture negate=
rx1107_cur."!cursor_pos"(rx1107_pos)
.const 'Sub' $P1113 = "49_1308626176.8564"
capture_lex $P1113
$P10 = rx1107_cur.$P1113()
unless $P10, rx1107_fail
rx1107_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"(0)
rx1107_pos = $P10."pos"()
# rx subrule $P1117 subtype=capture negate=
rx1107_cur."!cursor_pos"(rx1107_pos)
.const 'Sub' $P1117 = "50_1308626176.8564"
capture_lex $P1117
$P10 = rx1107_cur.$P1117()
unless $P10, rx1107_fail
rx1107_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("1")
rx1107_pos = $P10."pos"()
# rx subrule $P1122 subtype=capture negate=
rx1107_cur."!cursor_pos"(rx1107_pos)
.const 'Sub' $P1122 = "51_1308626176.8564"
capture_lex $P1122
$P10 = rx1107_cur.$P1122()
unless $P10, rx1107_fail
rx1107_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("2")
rx1107_pos = $P10."pos"()
# rx literal "}"
add $I11, rx1107_pos, 1
gt $I11, rx1107_eos, rx1107_fail
sub $I11, rx1107_pos, rx1107_off
ord $I11, rx1107_tgt, $I11
ne $I11, 125, rx1107_fail
add rx1107_pos, 1
.annotate 'line', 66
# rx subrule "obs" subtype=method negate=
rx1107_cur."!cursor_pos"(rx1107_pos)
$P10 = rx1107_cur."obs"("{N,M} as general quantifier", "** N..M (or ** N..*)")
unless $P10, rx1107_fail
rx1107_pos = $P10."pos"()
.annotate 'line', 65
# rx pass
rx1107_cur."!cursor_pass"(rx1107_pos, "quantifier:sym<{N,M}>")
if_null rx1107_debug, debug_258
rx1107_cur."!cursor_debug"("PASS", "quantifier:sym<{N,M}>", " at pos=", rx1107_pos)
debug_258:
.return (rx1107_cur)
rx1107_restart:
.annotate 'line', 3
if_null rx1107_debug, debug_259
rx1107_cur."!cursor_debug"("NEXT", "quantifier:sym<{N,M}>")
debug_259:
rx1107_fail:
(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
rx1107_done:
rx1107_cur."!cursor_fail"()
if_null rx1107_debug, debug_260
rx1107_cur."!cursor_debug"("FAIL", "quantifier:sym<{N,M}>")
debug_260:
.return (rx1107_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__quantifier:sym<{N,M}>" :subid("47_1308626176.8564") :method
.annotate 'line', 3
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "_block1110" :anon :subid("48_1308626176.8564") :outer("46_1308626176.8564")
.annotate 'line', 65
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "_block1112" :anon :subid("49_1308626176.8564") :method :outer("46_1308626176.8564")
.annotate 'line', 65
.local string rx1114_tgt
.local int rx1114_pos
.local int rx1114_off
.local int rx1114_eos
.local int rx1114_rep
.local pmc rx1114_cur
.local pmc rx1114_debug
(rx1114_cur, rx1114_pos, rx1114_tgt, $I10) = self."!cursor_start"()
getattribute rx1114_debug, rx1114_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1114_cur
.local pmc match
.lex "$/", match
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:
eq $I10, 1, rx1114_restart
if_null rx1114_debug, debug_246
rx1114_cur."!cursor_debug"("START", "")
debug_246:
$I10 = self.'from'()
ne $I10, -1, rxscan1115_done
goto rxscan1115_scan
rxscan1115_loop:
($P10) = rx1114_cur."from"()
inc $P10
set rx1114_pos, $P10
ge rx1114_pos, rx1114_eos, rxscan1115_done
rxscan1115_scan:
set_addr $I10, rxscan1115_loop
rx1114_cur."!mark_push"(0, rx1114_pos, $I10)
rxscan1115_done:
# rx charclass_q d r 1..-1
sub $I10, rx1114_pos, rx1114_off
find_not_cclass $I11, 8, rx1114_tgt, $I10, rx1114_eos
add $I12, $I10, 1
lt $I11, $I12, rx1114_fail
add rx1114_pos, rx1114_off, $I11
# rx pass
rx1114_cur."!cursor_pass"(rx1114_pos, "")
if_null rx1114_debug, debug_247
rx1114_cur."!cursor_debug"("PASS", "", " at pos=", rx1114_pos)
debug_247:
.return (rx1114_cur)
rx1114_restart:
if_null rx1114_debug, debug_248
rx1114_cur."!cursor_debug"("NEXT", "")
debug_248:
rx1114_fail:
(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
rx1114_done:
rx1114_cur."!cursor_fail"()
if_null rx1114_debug, debug_249
rx1114_cur."!cursor_debug"("FAIL", "")
debug_249:
.return (rx1114_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "_block1116" :anon :subid("50_1308626176.8564") :method :outer("46_1308626176.8564")
.annotate 'line', 65
.local string rx1118_tgt
.local int rx1118_pos
.local int rx1118_off
.local int rx1118_eos
.local int rx1118_rep
.local pmc rx1118_cur
.local pmc rx1118_debug
(rx1118_cur, rx1118_pos, rx1118_tgt, $I10) = self."!cursor_start"()
getattribute rx1118_debug, rx1118_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1118_cur
.local pmc match
.lex "$/", match
length rx1118_eos, rx1118_tgt
gt rx1118_pos, rx1118_eos, rx1118_done
set rx1118_off, 0
lt rx1118_pos, 2, rx1118_start
sub rx1118_off, rx1118_pos, 1
substr rx1118_tgt, rx1118_tgt, rx1118_off
rx1118_start:
eq $I10, 1, rx1118_restart
if_null rx1118_debug, debug_250
rx1118_cur."!cursor_debug"("START", "")
debug_250:
$I10 = self.'from'()
ne $I10, -1, rxscan1119_done
goto rxscan1119_scan
rxscan1119_loop:
($P10) = rx1118_cur."from"()
inc $P10
set rx1118_pos, $P10
ge rx1118_pos, rx1118_eos, rxscan1119_done
rxscan1119_scan:
set_addr $I10, rxscan1119_loop
rx1118_cur."!mark_push"(0, rx1118_pos, $I10)
rxscan1119_done:
# rx rxquantr1120 ** 0..1
set_addr $I10, rxquantr1120_done
rx1118_cur."!mark_push"(0, rx1118_pos, $I10)
rxquantr1120_loop:
# rx literal ","
add $I11, rx1118_pos, 1
gt $I11, rx1118_eos, rx1118_fail
sub $I11, rx1118_pos, rx1118_off
ord $I11, rx1118_tgt, $I11
ne $I11, 44, rx1118_fail
add rx1118_pos, 1
set_addr $I10, rxquantr1120_done
(rx1118_rep) = rx1118_cur."!mark_commit"($I10)
rxquantr1120_done:
# rx pass
rx1118_cur."!cursor_pass"(rx1118_pos, "")
if_null rx1118_debug, debug_251
rx1118_cur."!cursor_debug"("PASS", "", " at pos=", rx1118_pos)
debug_251:
.return (rx1118_cur)
rx1118_restart:
if_null rx1118_debug, debug_252
rx1118_cur."!cursor_debug"("NEXT", "")
debug_252:
rx1118_fail:
(rx1118_rep, rx1118_pos, $I10, $P10) = rx1118_cur."!mark_fail"(0)
lt rx1118_pos, -1, rx1118_done
eq rx1118_pos, -1, rx1118_fail
jump $I10
rx1118_done:
rx1118_cur."!cursor_fail"()
if_null rx1118_debug, debug_253
rx1118_cur."!cursor_debug"("FAIL", "")
debug_253:
.return (rx1118_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "_block1121" :anon :subid("51_1308626176.8564") :method :outer("46_1308626176.8564")
.annotate 'line', 65
.local string rx1123_tgt
.local int rx1123_pos
.local int rx1123_off
.local int rx1123_eos
.local int rx1123_rep
.local pmc rx1123_cur
.local pmc rx1123_debug
(rx1123_cur, rx1123_pos, rx1123_tgt, $I10) = self."!cursor_start"()
getattribute rx1123_debug, rx1123_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1123_cur
.local pmc match
.lex "$/", match
length rx1123_eos, rx1123_tgt
gt rx1123_pos, rx1123_eos, rx1123_done
set rx1123_off, 0
lt rx1123_pos, 2, rx1123_start
sub rx1123_off, rx1123_pos, 1
substr rx1123_tgt, rx1123_tgt, rx1123_off
rx1123_start:
eq $I10, 1, rx1123_restart
if_null rx1123_debug, debug_254
rx1123_cur."!cursor_debug"("START", "")
debug_254:
$I10 = self.'from'()
ne $I10, -1, rxscan1124_done
goto rxscan1124_scan
rxscan1124_loop:
($P10) = rx1123_cur."from"()
inc $P10
set rx1123_pos, $P10
ge rx1123_pos, rx1123_eos, rxscan1124_done
rxscan1124_scan:
set_addr $I10, rxscan1124_loop
rx1123_cur."!mark_push"(0, rx1123_pos, $I10)
rxscan1124_done:
# rx charclass_q d r 0..-1
sub $I10, rx1123_pos, rx1123_off
find_not_cclass $I11, 8, rx1123_tgt, $I10, rx1123_eos
add rx1123_pos, rx1123_off, $I11
# rx pass
rx1123_cur."!cursor_pass"(rx1123_pos, "")
if_null rx1123_debug, debug_255
rx1123_cur."!cursor_debug"("PASS", "", " at pos=", rx1123_pos)
debug_255:
.return (rx1123_cur)
rx1123_restart:
if_null rx1123_debug, debug_256
rx1123_cur."!cursor_debug"("NEXT", "")
debug_256:
rx1123_fail:
(rx1123_rep, rx1123_pos, $I10, $P10) = rx1123_cur."!mark_fail"(0)
lt rx1123_pos, -1, rx1123_done
eq rx1123_pos, -1, rx1123_fail
jump $I10
rx1123_done:
rx1123_cur."!cursor_fail"()
if_null rx1123_debug, debug_257
rx1123_cur."!cursor_debug"("FAIL", "")
debug_257:
.return (rx1123_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "quantifier:sym<**>" :subid("52_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1126_tgt
.local int rx1126_pos
.local int rx1126_off
.local int rx1126_eos
.local int rx1126_rep
.local pmc rx1126_cur
.local pmc rx1126_debug
(rx1126_cur, rx1126_pos, rx1126_tgt, $I10) = self."!cursor_start"()
rx1126_cur."!cursor_caparray"("normspace", "max")
getattribute rx1126_debug, rx1126_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1126_cur
.local pmc match
.lex "$/", match
length rx1126_eos, rx1126_tgt
gt rx1126_pos, rx1126_eos, rx1126_done
set rx1126_off, 0
lt rx1126_pos, 2, rx1126_start
sub rx1126_off, rx1126_pos, 1
substr rx1126_tgt, rx1126_tgt, rx1126_off
rx1126_start:
eq $I10, 1, rx1126_restart
if_null rx1126_debug, debug_261
rx1126_cur."!cursor_debug"("START", "quantifier:sym<**>")
debug_261:
$I10 = self.'from'()
ne $I10, -1, rxscan1128_done
goto rxscan1128_scan
rxscan1128_loop:
($P10) = rx1126_cur."from"()
inc $P10
set rx1126_pos, $P10
ge rx1126_pos, rx1126_eos, rxscan1128_done
rxscan1128_scan:
set_addr $I10, rxscan1128_loop
rx1126_cur."!mark_push"(0, rx1126_pos, $I10)
rxscan1128_done:
.annotate 'line', 69
# rx subcapture "sym"
set_addr $I10, rxcap_1129_fail
rx1126_cur."!mark_push"(0, rx1126_pos, $I10)
# rx literal "**"
add $I11, rx1126_pos, 2
gt $I11, rx1126_eos, rx1126_fail
sub $I11, rx1126_pos, rx1126_off
substr $S10, rx1126_tgt, $I11, 2
ne $S10, "**", rx1126_fail
add rx1126_pos, 2
set_addr $I10, rxcap_1129_fail
($I12, $I11) = rx1126_cur."!mark_peek"($I10)
rx1126_cur."!cursor_pos"($I11)
($P10) = rx1126_cur."!cursor_start"()
$P10."!cursor_pass"(rx1126_pos, "")
rx1126_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("sym")
goto rxcap_1129_done
rxcap_1129_fail:
goto rx1126_fail
rxcap_1129_done:
# rx rxquantr1130 ** 0..1
set_addr $I10, rxquantr1130_done
rx1126_cur."!mark_push"(0, rx1126_pos, $I10)
rxquantr1130_loop:
# rx subrule "normspace" subtype=capture negate=
rx1126_cur."!cursor_pos"(rx1126_pos)
$P10 = rx1126_cur."normspace"()
unless $P10, rx1126_fail
goto rxsubrule1131_pass
rxsubrule1131_back:
$P10 = $P10."!cursor_next"()
unless $P10, rx1126_fail
rxsubrule1131_pass:
set_addr $I10, rxsubrule1131_back
rx1126_cur."!mark_push"(0, rx1126_pos, $I10, $P10)
$P10."!cursor_names"("normspace")
rx1126_pos = $P10."pos"()
set_addr $I10, rxquantr1130_done
(rx1126_rep) = rx1126_cur."!mark_commit"($I10)
rxquantr1130_done:
# rx subrule "backmod" subtype=capture negate=
rx1126_cur."!cursor_pos"(rx1126_pos)
$P10 = rx1126_cur."backmod"()
unless $P10, rx1126_fail
rx1126_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("backmod")
rx1126_pos = $P10."pos"()
# rx rxquantr1132 ** 0..1
set_addr $I10, rxquantr1132_done
rx1126_cur."!mark_push"(0, rx1126_pos, $I10)
rxquantr1132_loop:
# rx subrule "normspace" subtype=capture negate=
rx1126_cur."!cursor_pos"(rx1126_pos)
$P10 = rx1126_cur."normspace"()
unless $P10, rx1126_fail
goto rxsubrule1133_pass
rxsubrule1133_back:
$P10 = $P10."!cursor_next"()
unless $P10, rx1126_fail
rxsubrule1133_pass:
set_addr $I10, rxsubrule1133_back
rx1126_cur."!mark_push"(0, rx1126_pos, $I10, $P10)
$P10."!cursor_names"("normspace")
rx1126_pos = $P10."pos"()
set_addr $I10, rxquantr1132_done
(rx1126_rep) = rx1126_cur."!mark_commit"($I10)
rxquantr1132_done:
alt1134_0:
.annotate 'line', 70
set_addr $I10, alt1134_1
rx1126_cur."!mark_push"(0, rx1126_pos, $I10)
.annotate 'line', 71
# rx subcapture "min"
set_addr $I10, rxcap_1135_fail
rx1126_cur."!mark_push"(0, rx1126_pos, $I10)
# rx charclass_q d r 1..-1
sub $I10, rx1126_pos, rx1126_off
find_not_cclass $I11, 8, rx1126_tgt, $I10, rx1126_eos
add $I12, $I10, 1
lt $I11, $I12, rx1126_fail
add rx1126_pos, rx1126_off, $I11
set_addr $I10, rxcap_1135_fail
($I12, $I11) = rx1126_cur."!mark_peek"($I10)
rx1126_cur."!cursor_pos"($I11)
($P10) = rx1126_cur."!cursor_start"()
$P10."!cursor_pass"(rx1126_pos, "")
rx1126_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("min")
goto rxcap_1135_done
rxcap_1135_fail:
goto rx1126_fail
rxcap_1135_done:
.annotate 'line', 78
# rx rxquantr1136 ** 0..1
set_addr $I10, rxquantr1136_done
rx1126_cur."!mark_push"(0, rx1126_pos, $I10)
rxquantr1136_loop:
.annotate 'line', 72
# rx literal ".."
add $I11, rx1126_pos, 2
gt $I11, rx1126_eos, rx1126_fail
sub $I11, rx1126_pos, rx1126_off
substr $S10, rx1126_tgt, $I11, 2
ne $S10, "..", rx1126_fail
add rx1126_pos, 2
.annotate 'line', 73
# rx subcapture "max"
set_addr $I10, rxcap_1138_fail
rx1126_cur."!mark_push"(0, rx1126_pos, $I10)
alt1137_0:
set_addr $I10, alt1137_1
rx1126_cur."!mark_push"(0, rx1126_pos, $I10)
.annotate 'line', 74
# rx charclass_q d r 1..-1
sub $I10, rx1126_pos, rx1126_off
find_not_cclass $I11, 8, rx1126_tgt, $I10, rx1126_eos
add $I12, $I10, 1
lt $I11, $I12, rx1126_fail
add rx1126_pos, rx1126_off, $I11
goto alt1137_end
alt1137_1:
set_addr $I10, alt1137_2
rx1126_cur."!mark_push"(0, rx1126_pos, $I10)
.annotate 'line', 75
# rx literal "*"
add $I11, rx1126_pos, 1
gt $I11, rx1126_eos, rx1126_fail
sub $I11, rx1126_pos, rx1126_off
ord $I11, rx1126_tgt, $I11
ne $I11, 42, rx1126_fail
add rx1126_pos, 1
goto alt1137_end
alt1137_2:
.annotate 'line', 76
# rx subrule "panic" subtype=method negate=
rx1126_cur."!cursor_pos"(rx1126_pos)
$P10 = rx1126_cur."panic"("Only integers or '*' allowed as range quantifier endpoint")
unless $P10, rx1126_fail
rx1126_pos = $P10."pos"()
alt1137_end:
.annotate 'line', 73
set_addr $I10, rxcap_1138_fail
($I12, $I11) = rx1126_cur."!mark_peek"($I10)
rx1126_cur."!cursor_pos"($I11)
($P10) = rx1126_cur."!cursor_start"()
$P10."!cursor_pass"(rx1126_pos, "")
rx1126_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("max")
goto rxcap_1138_done
rxcap_1138_fail:
goto rx1126_fail
rxcap_1138_done:
.annotate 'line', 78
set_addr $I10, rxquantr1136_done
(rx1126_rep) = rx1126_cur."!mark_commit"($I10)
rxquantr1136_done:
.annotate 'line', 71
goto alt1134_end
alt1134_1:
.annotate 'line', 79
# rx subrule "quantified_atom" subtype=capture negate=
rx1126_cur."!cursor_pos"(rx1126_pos)
$P10 = rx1126_cur."quantified_atom"()
unless $P10, rx1126_fail
rx1126_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("quantified_atom")
rx1126_pos = $P10."pos"()
alt1134_end:
.annotate 'line', 68
# rx pass
rx1126_cur."!cursor_pass"(rx1126_pos, "quantifier:sym<**>")
if_null rx1126_debug, debug_262
rx1126_cur."!cursor_debug"("PASS", "quantifier:sym<**>", " at pos=", rx1126_pos)
debug_262:
.return (rx1126_cur)
rx1126_restart:
.annotate 'line', 3
if_null rx1126_debug, debug_263
rx1126_cur."!cursor_debug"("NEXT", "quantifier:sym<**>")
debug_263:
rx1126_fail:
(rx1126_rep, rx1126_pos, $I10, $P10) = rx1126_cur."!mark_fail"(0)
lt rx1126_pos, -1, rx1126_done
eq rx1126_pos, -1, rx1126_fail
jump $I10
rx1126_done:
rx1126_cur."!cursor_fail"()
if_null rx1126_debug, debug_264
rx1126_cur."!cursor_debug"("FAIL", "quantifier:sym<**>")
debug_264:
.return (rx1126_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__quantifier:sym<**>" :subid("53_1308626176.8564") :method
.annotate 'line', 3
new $P100, "ResizablePMCArray"
push $P100, "**"
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "backmod" :subid("54_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.const 'Sub' $P1146 = "56_1308626176.8564"
capture_lex $P1146
.local string rx1140_tgt
.local int rx1140_pos
.local int rx1140_off
.local int rx1140_eos
.local int rx1140_rep
.local pmc rx1140_cur
.local pmc rx1140_debug
(rx1140_cur, rx1140_pos, rx1140_tgt, $I10) = self."!cursor_start"()
getattribute rx1140_debug, rx1140_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1140_cur
.local pmc match
.lex "$/", match
length rx1140_eos, rx1140_tgt
gt rx1140_pos, rx1140_eos, rx1140_done
set rx1140_off, 0
lt rx1140_pos, 2, rx1140_start
sub rx1140_off, rx1140_pos, 1
substr rx1140_tgt, rx1140_tgt, rx1140_off
rx1140_start:
eq $I10, 1, rx1140_restart
if_null rx1140_debug, debug_265
rx1140_cur."!cursor_debug"("START", "backmod")
debug_265:
$I10 = self.'from'()
ne $I10, -1, rxscan1142_done
goto rxscan1142_scan
rxscan1142_loop:
($P10) = rx1140_cur."from"()
inc $P10
set rx1140_pos, $P10
ge rx1140_pos, rx1140_eos, rxscan1142_done
rxscan1142_scan:
set_addr $I10, rxscan1142_loop
rx1140_cur."!mark_push"(0, rx1140_pos, $I10)
rxscan1142_done:
.annotate 'line', 83
# rx rxquantr1143 ** 0..1
set_addr $I10, rxquantr1143_done
rx1140_cur."!mark_push"(0, rx1140_pos, $I10)
rxquantr1143_loop:
# rx literal ":"
add $I11, rx1140_pos, 1
gt $I11, rx1140_eos, rx1140_fail
sub $I11, rx1140_pos, rx1140_off
ord $I11, rx1140_tgt, $I11
ne $I11, 58, rx1140_fail
add rx1140_pos, 1
set_addr $I10, rxquantr1143_done
(rx1140_rep) = rx1140_cur."!mark_commit"($I10)
rxquantr1143_done:
alt1144_0:
set_addr $I10, alt1144_1
rx1140_cur."!mark_push"(0, rx1140_pos, $I10)
# rx literal "?"
add $I11, rx1140_pos, 1
gt $I11, rx1140_eos, rx1140_fail
sub $I11, rx1140_pos, rx1140_off
ord $I11, rx1140_tgt, $I11
ne $I11, 63, rx1140_fail
add rx1140_pos, 1
goto alt1144_end
alt1144_1:
set_addr $I10, alt1144_2
rx1140_cur."!mark_push"(0, rx1140_pos, $I10)
# rx literal "!"
add $I11, rx1140_pos, 1
gt $I11, rx1140_eos, rx1140_fail
sub $I11, rx1140_pos, rx1140_off
ord $I11, rx1140_tgt, $I11
ne $I11, 33, rx1140_fail
add rx1140_pos, 1
goto alt1144_end
alt1144_2:
# rx subrule "before" subtype=zerowidth negate=1
rx1140_cur."!cursor_pos"(rx1140_pos)
.const 'Sub' $P1146 = "56_1308626176.8564"
capture_lex $P1146
$P10 = rx1140_cur."before"($P1146)
if $P10, rx1140_fail
alt1144_end:
# rx pass
rx1140_cur."!cursor_pass"(rx1140_pos, "backmod")
if_null rx1140_debug, debug_270
rx1140_cur."!cursor_debug"("PASS", "backmod", " at pos=", rx1140_pos)
debug_270:
.return (rx1140_cur)
rx1140_restart:
.annotate 'line', 3
if_null rx1140_debug, debug_271
rx1140_cur."!cursor_debug"("NEXT", "backmod")
debug_271:
rx1140_fail:
(rx1140_rep, rx1140_pos, $I10, $P10) = rx1140_cur."!mark_fail"(0)
lt rx1140_pos, -1, rx1140_done
eq rx1140_pos, -1, rx1140_fail
jump $I10
rx1140_done:
rx1140_cur."!cursor_fail"()
if_null rx1140_debug, debug_272
rx1140_cur."!cursor_debug"("FAIL", "backmod")
debug_272:
.return (rx1140_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__backmod" :subid("55_1308626176.8564") :method
.annotate 'line', 3
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "_block1145" :anon :subid("56_1308626176.8564") :method :outer("54_1308626176.8564")
.annotate 'line', 83
.local string rx1147_tgt
.local int rx1147_pos
.local int rx1147_off
.local int rx1147_eos
.local int rx1147_rep
.local pmc rx1147_cur
.local pmc rx1147_debug
(rx1147_cur, rx1147_pos, rx1147_tgt, $I10) = self."!cursor_start"()
getattribute rx1147_debug, rx1147_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1147_cur
.local pmc match
.lex "$/", match
length rx1147_eos, rx1147_tgt
gt rx1147_pos, rx1147_eos, rx1147_done
set rx1147_off, 0
lt rx1147_pos, 2, rx1147_start
sub rx1147_off, rx1147_pos, 1
substr rx1147_tgt, rx1147_tgt, rx1147_off
rx1147_start:
eq $I10, 1, rx1147_restart
if_null rx1147_debug, debug_266
rx1147_cur."!cursor_debug"("START", "")
debug_266:
$I10 = self.'from'()
ne $I10, -1, rxscan1148_done
goto rxscan1148_scan
rxscan1148_loop:
($P10) = rx1147_cur."from"()
inc $P10
set rx1147_pos, $P10
ge rx1147_pos, rx1147_eos, rxscan1148_done
rxscan1148_scan:
set_addr $I10, rxscan1148_loop
rx1147_cur."!mark_push"(0, rx1147_pos, $I10)
rxscan1148_done:
# rx literal ":"
add $I11, rx1147_pos, 1
gt $I11, rx1147_eos, rx1147_fail
sub $I11, rx1147_pos, rx1147_off
ord $I11, rx1147_tgt, $I11
ne $I11, 58, rx1147_fail
add rx1147_pos, 1
# rx pass
rx1147_cur."!cursor_pass"(rx1147_pos, "")
if_null rx1147_debug, debug_267
rx1147_cur."!cursor_debug"("PASS", "", " at pos=", rx1147_pos)
debug_267:
.return (rx1147_cur)
rx1147_restart:
if_null rx1147_debug, debug_268
rx1147_cur."!cursor_debug"("NEXT", "")
debug_268:
rx1147_fail:
(rx1147_rep, rx1147_pos, $I10, $P10) = rx1147_cur."!mark_fail"(0)
lt rx1147_pos, -1, rx1147_done
eq rx1147_pos, -1, rx1147_fail
jump $I10
rx1147_done:
rx1147_cur."!cursor_fail"()
if_null rx1147_debug, debug_269
rx1147_cur."!cursor_debug"("FAIL", "")
debug_269:
.return (rx1147_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "metachar" :subid("57_1308626176.8564") :method
.annotate 'line', 85
$P100 = self."!protoregex"("metachar")
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__metachar" :subid("58_1308626176.8564") :method
.annotate 'line', 85
$P101 = self."!PREFIX__!protoregex"("metachar")
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "metachar:sym<ws>" :subid("59_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1152_tgt
.local int rx1152_pos
.local int rx1152_off
.local int rx1152_eos
.local int rx1152_rep
.local pmc rx1152_cur
.local pmc rx1152_debug
(rx1152_cur, rx1152_pos, rx1152_tgt, $I10) = self."!cursor_start"()
getattribute rx1152_debug, rx1152_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1152_cur
.local pmc match
.lex "$/", match
length rx1152_eos, rx1152_tgt
gt rx1152_pos, rx1152_eos, rx1152_done
set rx1152_off, 0
lt rx1152_pos, 2, rx1152_start
sub rx1152_off, rx1152_pos, 1
substr rx1152_tgt, rx1152_tgt, rx1152_off
rx1152_start:
eq $I10, 1, rx1152_restart
if_null rx1152_debug, debug_273
rx1152_cur."!cursor_debug"("START", "metachar:sym<ws>")
debug_273:
$I10 = self.'from'()
ne $I10, -1, rxscan1154_done
goto rxscan1154_scan
rxscan1154_loop:
($P10) = rx1152_cur."from"()
inc $P10
set rx1152_pos, $P10
ge rx1152_pos, rx1152_eos, rxscan1154_done
rxscan1154_scan:
set_addr $I10, rxscan1154_loop
rx1152_cur."!mark_push"(0, rx1152_pos, $I10)
rxscan1154_done:
.annotate 'line', 86
# rx subrule "normspace" subtype=method negate=
rx1152_cur."!cursor_pos"(rx1152_pos)
$P10 = rx1152_cur."normspace"()
unless $P10, rx1152_fail
rx1152_pos = $P10."pos"()
# rx pass
rx1152_cur."!cursor_pass"(rx1152_pos, "metachar:sym<ws>")
if_null rx1152_debug, debug_274
rx1152_cur."!cursor_debug"("PASS", "metachar:sym<ws>", " at pos=", rx1152_pos)
debug_274:
.return (rx1152_cur)
rx1152_restart:
.annotate 'line', 3
if_null rx1152_debug, debug_275
rx1152_cur."!cursor_debug"("NEXT", "metachar:sym<ws>")
debug_275:
rx1152_fail:
(rx1152_rep, rx1152_pos, $I10, $P10) = rx1152_cur."!mark_fail"(0)
lt rx1152_pos, -1, rx1152_done
eq rx1152_pos, -1, rx1152_fail
jump $I10
rx1152_done:
rx1152_cur."!cursor_fail"()
if_null rx1152_debug, debug_276
rx1152_cur."!cursor_debug"("FAIL", "metachar:sym<ws>")
debug_276:
.return (rx1152_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__metachar:sym<ws>" :subid("60_1308626176.8564") :method
.annotate 'line', 3
$P100 = self."!PREFIX__!subrule"("normspace", "")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "metachar:sym<[ ]>" :subid("61_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1156_tgt
.local int rx1156_pos
.local int rx1156_off
.local int rx1156_eos
.local int rx1156_rep
.local pmc rx1156_cur
.local pmc rx1156_debug
(rx1156_cur, rx1156_pos, rx1156_tgt, $I10) = self."!cursor_start"()
getattribute rx1156_debug, rx1156_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1156_cur
.local pmc match
.lex "$/", match
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:
eq $I10, 1, rx1156_restart
if_null rx1156_debug, debug_277
rx1156_cur."!cursor_debug"("START", "metachar:sym<[ ]>")
debug_277:
$I10 = self.'from'()
ne $I10, -1, rxscan1158_done
goto rxscan1158_scan
rxscan1158_loop:
($P10) = rx1156_cur."from"()
inc $P10
set rx1156_pos, $P10
ge rx1156_pos, rx1156_eos, rxscan1158_done
rxscan1158_scan:
set_addr $I10, rxscan1158_loop
rx1156_cur."!mark_push"(0, rx1156_pos, $I10)
rxscan1158_done:
.annotate 'line', 87
# rx literal "["
add $I11, rx1156_pos, 1
gt $I11, rx1156_eos, rx1156_fail
sub $I11, rx1156_pos, rx1156_off
ord $I11, rx1156_tgt, $I11
ne $I11, 91, rx1156_fail
add rx1156_pos, 1
# rx subrule "nibbler" subtype=capture negate=
rx1156_cur."!cursor_pos"(rx1156_pos)
$P10 = rx1156_cur."nibbler"()
unless $P10, rx1156_fail
rx1156_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("nibbler")
rx1156_pos = $P10."pos"()
# rx literal "]"
add $I11, rx1156_pos, 1
gt $I11, rx1156_eos, rx1156_fail
sub $I11, rx1156_pos, rx1156_off
ord $I11, rx1156_tgt, $I11
ne $I11, 93, rx1156_fail
add rx1156_pos, 1
# rx pass
rx1156_cur."!cursor_pass"(rx1156_pos, "metachar:sym<[ ]>")
if_null rx1156_debug, debug_278
rx1156_cur."!cursor_debug"("PASS", "metachar:sym<[ ]>", " at pos=", rx1156_pos)
debug_278:
.return (rx1156_cur)
rx1156_restart:
.annotate 'line', 3
if_null rx1156_debug, debug_279
rx1156_cur."!cursor_debug"("NEXT", "metachar:sym<[ ]>")
debug_279:
rx1156_fail:
(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
rx1156_done:
rx1156_cur."!cursor_fail"()
if_null rx1156_debug, debug_280
rx1156_cur."!cursor_debug"("FAIL", "metachar:sym<[ ]>")
debug_280:
.return (rx1156_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__metachar:sym<[ ]>" :subid("62_1308626176.8564") :method
.annotate 'line', 3
$P100 = self."!PREFIX__!subrule"("nibbler", "[")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "metachar:sym<( )>" :subid("63_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1160_tgt
.local int rx1160_pos
.local int rx1160_off
.local int rx1160_eos
.local int rx1160_rep
.local pmc rx1160_cur
.local pmc rx1160_debug
(rx1160_cur, rx1160_pos, rx1160_tgt, $I10) = self."!cursor_start"()
getattribute rx1160_debug, rx1160_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1160_cur
.local pmc match
.lex "$/", match
length rx1160_eos, rx1160_tgt
gt rx1160_pos, rx1160_eos, rx1160_done
set rx1160_off, 0
lt rx1160_pos, 2, rx1160_start
sub rx1160_off, rx1160_pos, 1
substr rx1160_tgt, rx1160_tgt, rx1160_off
rx1160_start:
eq $I10, 1, rx1160_restart
if_null rx1160_debug, debug_281
rx1160_cur."!cursor_debug"("START", "metachar:sym<( )>")
debug_281:
$I10 = self.'from'()
ne $I10, -1, rxscan1162_done
goto rxscan1162_scan
rxscan1162_loop:
($P10) = rx1160_cur."from"()
inc $P10
set rx1160_pos, $P10
ge rx1160_pos, rx1160_eos, rxscan1162_done
rxscan1162_scan:
set_addr $I10, rxscan1162_loop
rx1160_cur."!mark_push"(0, rx1160_pos, $I10)
rxscan1162_done:
.annotate 'line', 88
# rx literal "("
add $I11, rx1160_pos, 1
gt $I11, rx1160_eos, rx1160_fail
sub $I11, rx1160_pos, rx1160_off
ord $I11, rx1160_tgt, $I11
ne $I11, 40, rx1160_fail
add rx1160_pos, 1
# rx subrule "nibbler" subtype=capture negate=
rx1160_cur."!cursor_pos"(rx1160_pos)
$P10 = rx1160_cur."nibbler"()
unless $P10, rx1160_fail
rx1160_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("nibbler")
rx1160_pos = $P10."pos"()
# rx literal ")"
add $I11, rx1160_pos, 1
gt $I11, rx1160_eos, rx1160_fail
sub $I11, rx1160_pos, rx1160_off
ord $I11, rx1160_tgt, $I11
ne $I11, 41, rx1160_fail
add rx1160_pos, 1
# rx pass
rx1160_cur."!cursor_pass"(rx1160_pos, "metachar:sym<( )>")
if_null rx1160_debug, debug_282
rx1160_cur."!cursor_debug"("PASS", "metachar:sym<( )>", " at pos=", rx1160_pos)
debug_282:
.return (rx1160_cur)
rx1160_restart:
.annotate 'line', 3
if_null rx1160_debug, debug_283
rx1160_cur."!cursor_debug"("NEXT", "metachar:sym<( )>")
debug_283:
rx1160_fail:
(rx1160_rep, rx1160_pos, $I10, $P10) = rx1160_cur."!mark_fail"(0)
lt rx1160_pos, -1, rx1160_done
eq rx1160_pos, -1, rx1160_fail
jump $I10
rx1160_done:
rx1160_cur."!cursor_fail"()
if_null rx1160_debug, debug_284
rx1160_cur."!cursor_debug"("FAIL", "metachar:sym<( )>")
debug_284:
.return (rx1160_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__metachar:sym<( )>" :subid("64_1308626176.8564") :method
.annotate 'line', 3
$P100 = self."!PREFIX__!subrule"("nibbler", "(")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "metachar:sym<'>" :subid("65_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1164_tgt
.local int rx1164_pos
.local int rx1164_off
.local int rx1164_eos
.local int rx1164_rep
.local pmc rx1164_cur
.local pmc rx1164_debug
(rx1164_cur, rx1164_pos, rx1164_tgt, $I10) = self."!cursor_start"()
getattribute rx1164_debug, rx1164_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1164_cur
.local pmc match
.lex "$/", match
length rx1164_eos, rx1164_tgt
gt rx1164_pos, rx1164_eos, rx1164_done
set rx1164_off, 0
lt rx1164_pos, 2, rx1164_start
sub rx1164_off, rx1164_pos, 1
substr rx1164_tgt, rx1164_tgt, rx1164_off
rx1164_start:
eq $I10, 1, rx1164_restart
if_null rx1164_debug, debug_285
rx1164_cur."!cursor_debug"("START", "metachar:sym<'>")
debug_285:
$I10 = self.'from'()
ne $I10, -1, rxscan1166_done
goto rxscan1166_scan
rxscan1166_loop:
($P10) = rx1164_cur."from"()
inc $P10
set rx1164_pos, $P10
ge rx1164_pos, rx1164_eos, rxscan1166_done
rxscan1166_scan:
set_addr $I10, rxscan1166_loop
rx1164_cur."!mark_push"(0, rx1164_pos, $I10)
rxscan1166_done:
.annotate 'line', 89
# rx enumcharlist negate=0 zerowidth
sub $I10, rx1164_pos, rx1164_off
substr $S10, rx1164_tgt, $I10, 1
index $I11, "'", $S10
lt $I11, 0, rx1164_fail
# rx subrule "quote_EXPR" subtype=capture negate=
rx1164_cur."!cursor_pos"(rx1164_pos)
$P10 = rx1164_cur."quote_EXPR"(":q")
unless $P10, rx1164_fail
rx1164_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("quote_EXPR")
rx1164_pos = $P10."pos"()
# rx pass
rx1164_cur."!cursor_pass"(rx1164_pos, "metachar:sym<'>")
if_null rx1164_debug, debug_286
rx1164_cur."!cursor_debug"("PASS", "metachar:sym<'>", " at pos=", rx1164_pos)
debug_286:
.return (rx1164_cur)
rx1164_restart:
.annotate 'line', 3
if_null rx1164_debug, debug_287
rx1164_cur."!cursor_debug"("NEXT", "metachar:sym<'>")
debug_287:
rx1164_fail:
(rx1164_rep, rx1164_pos, $I10, $P10) = rx1164_cur."!mark_fail"(0)
lt rx1164_pos, -1, rx1164_done
eq rx1164_pos, -1, rx1164_fail
jump $I10
rx1164_done:
rx1164_cur."!cursor_fail"()
if_null rx1164_debug, debug_288
rx1164_cur."!cursor_debug"("FAIL", "metachar:sym<'>")
debug_288:
.return (rx1164_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__metachar:sym<'>" :subid("66_1308626176.8564") :method
.annotate 'line', 3
new $P100, "ResizablePMCArray"
push $P100, "'"
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "metachar:sym<\">" :subid("67_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1168_tgt
.local int rx1168_pos
.local int rx1168_off
.local int rx1168_eos
.local int rx1168_rep
.local pmc rx1168_cur
.local pmc rx1168_debug
(rx1168_cur, rx1168_pos, rx1168_tgt, $I10) = self."!cursor_start"()
getattribute rx1168_debug, rx1168_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1168_cur
.local pmc match
.lex "$/", match
length rx1168_eos, rx1168_tgt
gt rx1168_pos, rx1168_eos, rx1168_done
set rx1168_off, 0
lt rx1168_pos, 2, rx1168_start
sub rx1168_off, rx1168_pos, 1
substr rx1168_tgt, rx1168_tgt, rx1168_off
rx1168_start:
eq $I10, 1, rx1168_restart
if_null rx1168_debug, debug_289
rx1168_cur."!cursor_debug"("START", "metachar:sym<\">")
debug_289:
$I10 = self.'from'()
ne $I10, -1, rxscan1170_done
goto rxscan1170_scan
rxscan1170_loop:
($P10) = rx1168_cur."from"()
inc $P10
set rx1168_pos, $P10
ge rx1168_pos, rx1168_eos, rxscan1170_done
rxscan1170_scan:
set_addr $I10, rxscan1170_loop
rx1168_cur."!mark_push"(0, rx1168_pos, $I10)
rxscan1170_done:
.annotate 'line', 90
# rx enumcharlist negate=0 zerowidth
sub $I10, rx1168_pos, rx1168_off
substr $S10, rx1168_tgt, $I10, 1
index $I11, "\"", $S10
lt $I11, 0, rx1168_fail
# rx subrule "quote_EXPR" subtype=capture negate=
rx1168_cur."!cursor_pos"(rx1168_pos)
$P10 = rx1168_cur."quote_EXPR"(":qq")
unless $P10, rx1168_fail
rx1168_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("quote_EXPR")
rx1168_pos = $P10."pos"()
# rx pass
rx1168_cur."!cursor_pass"(rx1168_pos, "metachar:sym<\">")
if_null rx1168_debug, debug_290
rx1168_cur."!cursor_debug"("PASS", "metachar:sym<\">", " at pos=", rx1168_pos)
debug_290:
.return (rx1168_cur)
rx1168_restart:
.annotate 'line', 3
if_null rx1168_debug, debug_291
rx1168_cur."!cursor_debug"("NEXT", "metachar:sym<\">")
debug_291:
rx1168_fail:
(rx1168_rep, rx1168_pos, $I10, $P10) = rx1168_cur."!mark_fail"(0)
lt rx1168_pos, -1, rx1168_done
eq rx1168_pos, -1, rx1168_fail
jump $I10
rx1168_done:
rx1168_cur."!cursor_fail"()
if_null rx1168_debug, debug_292
rx1168_cur."!cursor_debug"("FAIL", "metachar:sym<\">")
debug_292:
.return (rx1168_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__metachar:sym<\">" :subid("68_1308626176.8564") :method
.annotate 'line', 3
new $P100, "ResizablePMCArray"
push $P100, "\""
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "metachar:sym<.>" :subid("69_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1172_tgt
.local int rx1172_pos
.local int rx1172_off
.local int rx1172_eos
.local int rx1172_rep
.local pmc rx1172_cur
.local pmc rx1172_debug
(rx1172_cur, rx1172_pos, rx1172_tgt, $I10) = self."!cursor_start"()
getattribute rx1172_debug, rx1172_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1172_cur
.local pmc match
.lex "$/", match
length rx1172_eos, rx1172_tgt
gt rx1172_pos, rx1172_eos, rx1172_done
set rx1172_off, 0
lt rx1172_pos, 2, rx1172_start
sub rx1172_off, rx1172_pos, 1
substr rx1172_tgt, rx1172_tgt, rx1172_off
rx1172_start:
eq $I10, 1, rx1172_restart
if_null rx1172_debug, debug_293
rx1172_cur."!cursor_debug"("START", "metachar:sym<.>")
debug_293:
$I10 = self.'from'()
ne $I10, -1, rxscan1174_done
goto rxscan1174_scan
rxscan1174_loop:
($P10) = rx1172_cur."from"()
inc $P10
set rx1172_pos, $P10
ge rx1172_pos, rx1172_eos, rxscan1174_done
rxscan1174_scan:
set_addr $I10, rxscan1174_loop
rx1172_cur."!mark_push"(0, rx1172_pos, $I10)
rxscan1174_done:
.annotate 'line', 91
# rx subcapture "sym"
set_addr $I10, rxcap_1175_fail
rx1172_cur."!mark_push"(0, rx1172_pos, $I10)
# rx literal "."
add $I11, rx1172_pos, 1
gt $I11, rx1172_eos, rx1172_fail
sub $I11, rx1172_pos, rx1172_off
ord $I11, rx1172_tgt, $I11
ne $I11, 46, rx1172_fail
add rx1172_pos, 1
set_addr $I10, rxcap_1175_fail
($I12, $I11) = rx1172_cur."!mark_peek"($I10)
rx1172_cur."!cursor_pos"($I11)
($P10) = rx1172_cur."!cursor_start"()
$P10."!cursor_pass"(rx1172_pos, "")
rx1172_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("sym")
goto rxcap_1175_done
rxcap_1175_fail:
goto rx1172_fail
rxcap_1175_done:
# rx pass
rx1172_cur."!cursor_pass"(rx1172_pos, "metachar:sym<.>")
if_null rx1172_debug, debug_294
rx1172_cur."!cursor_debug"("PASS", "metachar:sym<.>", " at pos=", rx1172_pos)
debug_294:
.return (rx1172_cur)
rx1172_restart:
.annotate 'line', 3
if_null rx1172_debug, debug_295
rx1172_cur."!cursor_debug"("NEXT", "metachar:sym<.>")
debug_295:
rx1172_fail:
(rx1172_rep, rx1172_pos, $I10, $P10) = rx1172_cur."!mark_fail"(0)
lt rx1172_pos, -1, rx1172_done
eq rx1172_pos, -1, rx1172_fail
jump $I10
rx1172_done:
rx1172_cur."!cursor_fail"()
if_null rx1172_debug, debug_296
rx1172_cur."!cursor_debug"("FAIL", "metachar:sym<.>")
debug_296:
.return (rx1172_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__metachar:sym<.>" :subid("70_1308626176.8564") :method
.annotate 'line', 3
new $P100, "ResizablePMCArray"
push $P100, "."
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "metachar:sym<^>" :subid("71_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1177_tgt
.local int rx1177_pos
.local int rx1177_off
.local int rx1177_eos
.local int rx1177_rep
.local pmc rx1177_cur
.local pmc rx1177_debug
(rx1177_cur, rx1177_pos, rx1177_tgt, $I10) = self."!cursor_start"()
getattribute rx1177_debug, rx1177_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1177_cur
.local pmc match
.lex "$/", match
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:
eq $I10, 1, rx1177_restart
if_null rx1177_debug, debug_297
rx1177_cur."!cursor_debug"("START", "metachar:sym<^>")
debug_297:
$I10 = self.'from'()
ne $I10, -1, rxscan1179_done
goto rxscan1179_scan
rxscan1179_loop:
($P10) = rx1177_cur."from"()
inc $P10
set rx1177_pos, $P10
ge rx1177_pos, rx1177_eos, rxscan1179_done
rxscan1179_scan:
set_addr $I10, rxscan1179_loop
rx1177_cur."!mark_push"(0, rx1177_pos, $I10)
rxscan1179_done:
.annotate 'line', 92
# rx subcapture "sym"
set_addr $I10, rxcap_1180_fail
rx1177_cur."!mark_push"(0, rx1177_pos, $I10)
# rx literal "^"
add $I11, rx1177_pos, 1
gt $I11, rx1177_eos, rx1177_fail
sub $I11, rx1177_pos, rx1177_off
ord $I11, rx1177_tgt, $I11
ne $I11, 94, rx1177_fail
add rx1177_pos, 1
set_addr $I10, rxcap_1180_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_1180_done
rxcap_1180_fail:
goto rx1177_fail
rxcap_1180_done:
# rx pass
rx1177_cur."!cursor_pass"(rx1177_pos, "metachar:sym<^>")
if_null rx1177_debug, debug_298
rx1177_cur."!cursor_debug"("PASS", "metachar:sym<^>", " at pos=", rx1177_pos)
debug_298:
.return (rx1177_cur)
rx1177_restart:
.annotate 'line', 3
if_null rx1177_debug, debug_299
rx1177_cur."!cursor_debug"("NEXT", "metachar:sym<^>")
debug_299:
rx1177_fail:
(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
rx1177_done:
rx1177_cur."!cursor_fail"()
if_null rx1177_debug, debug_300
rx1177_cur."!cursor_debug"("FAIL", "metachar:sym<^>")
debug_300:
.return (rx1177_cur)
.return ()
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "!PREFIX__metachar:sym<^>" :subid("72_1308626176.8564") :method
.annotate 'line', 3
new $P100, "ResizablePMCArray"
push $P100, "^"
.return ($P100)
.end
.namespace ["Regex";"P6Regex";"Grammar"]
.sub "metachar:sym<^^>" :subid("73_1308626176.8564") :method :outer("11_1308626176.8564")
.annotate 'line', 3
.local string rx1182_tgt
.local int rx1182_pos
.local int rx1182_off
.local int rx1182_eos
.local int rx1182_rep
.local pmc rx1182_cur
.local pmc rx1182_debug
(rx1182_cur, rx1182_pos, rx1182_tgt, $I10) = self."!cursor_start"()
getattribute rx1182_debug, rx1182_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1182_cur
.local pmc match
.lex "$/", match
length rx1182_eos, rx1182_tgt