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

8999 lines (8460 sloc) 257.119 kb
#
=head1 NAME
HLL - Parrot HLL library
=head1 DESCRIPTION
This file brings together the various modules needed for HLL::Compiler
and HLL::Grammar.
=over 4
=cut
.sub '' :anon :load :init
load_bytecode 'Regex.pbc'
.end
### .include 'src/cheats/hll-compiler.pir'
# we have to overload PCT::HLLCompiler's parse method to support P6Regex grammars
.include 'cclass.pasm'
.namespace ['HLL';'Compiler']
.sub 'parse' :method
.param pmc source
.param pmc options :slurpy :named
.local string tcode
tcode = options['transcode']
unless tcode goto transcode_done
.local pmc tcode_it
$P0 = split ' ', tcode
tcode_it = iter $P0
tcode_loop:
unless tcode_it goto transcode_done
tcode = shift tcode_it
push_eh tcode_fail
$I0 = find_encoding tcode
$S0 = source
$S0 = trans_encoding $S0, $I0
assign source, $S0
pop_eh
goto transcode_done
tcode_fail:
pop_eh
goto tcode_loop
transcode_done:
.local pmc parsegrammar, parseactions, match
parsegrammar = self.'parsegrammar'()
null parseactions
$S0 = options['target']
if $S0 == 'parse' goto have_parseactions
parseactions = self.'parseactions'()
have_parseactions:
.local int rxtrace
rxtrace = options['parsetrace']
match = parsegrammar.'parse'(source, 'p'=>0, 'actions'=>parseactions, 'rxtrace'=>rxtrace)
unless match goto err_parsefail
.return (match)
err_parsefail:
self.'panic'('Unable to parse source')
.return (match)
.end
.sub 'pir' :method
.param pmc source
.param pmc adverbs :slurpy :named
$P0 = compreg 'POST'
$S0 = $P0.'to_pir'(source, adverbs :flat :named)
.return ($S0)
.end
.sub 'parse_name' :method
.param string name
# split name on ::
.local pmc ns
ns = split '::', name
# move any leading sigil to the last item
.local string sigil
$S0 = ns[0]
sigil = substr $S0, 0, 1
$I0 = index '$@%&', sigil
if $I0 < 0 goto sigil_done
$S0 = replace $S0, 0, 1, ''
ns[0] = $S0
$S0 = ns[-1]
$S0 = concat sigil, $S0
ns[-1] = $S0
sigil_done:
# remove any empty items from the list
.local pmc ns_it
ns_it = iter ns
ns = new ['ResizablePMCArray']
ns_loop:
unless ns_it goto ns_done
$S0 = shift ns_it
unless $S0 > '' goto ns_loop
push ns, $S0
goto ns_loop
ns_done:
# return the result
.return (ns)
.end
# Temporarily backport PCT::HLLCompiler's 'lineof' method
# from Parrot r48866 into HLL::Compiler, so that nqp-rx can
# continue to build from an older Parrot until parrot's trunk
# is working again. When we're able to bump PARROT_REVISION,
# this code can go away to fall back to Parrot's version (DRY).
=item lineof(target, pos [, cache :named('cache')])
Return the line number of offset C<pos> within C<target>. The return
value uses zero for the first line. If C<cache> is true, then
memoize the line offsets as a C<!lineof> property on C<target>.
=cut
.sub 'lineof' :method
.param pmc target
.param int pos
.param int cache :optional :named('cache')
.local pmc linepos
# If we've previously cached C<linepos> for target, we use it.
unless cache goto linepos_build
linepos = getprop '!linepos', target
unless null linepos goto linepos_done
# calculate a new linepos array.
linepos_build:
linepos = new ['ResizableIntegerArray']
unless cache goto linepos_build_1
setprop target, '!linepos', linepos
linepos_build_1:
.local string s
.local int jpos, eos
s = target
eos = length s
jpos = 0
# Search for all of the newline markers in C<target>. When we
# find one, mark the ending offset of the line in C<linepos>.
linepos_loop:
jpos = find_cclass .CCLASS_NEWLINE, s, jpos, eos
unless jpos < eos goto linepos_done
$I0 = ord s, jpos
inc jpos
push linepos, jpos
# Treat \r\n as a single logical newline.
if $I0 != 13 goto linepos_loop
$I0 = ord s, jpos
if $I0 != 10 goto linepos_loop
inc jpos
goto linepos_loop
linepos_done:
# We have C<linepos>, so now we search the array for the largest
# element that is not greater than C<pos>. The index of that
# element is the line number to be returned.
# (Potential optimization: use a binary search.)
.local int line, count
count = elements linepos
line = 0
line_loop:
if line >= count goto line_done
$I0 = linepos[line]
if $I0 > pos goto line_done
inc line
goto line_loop
line_done:
.return (line)
.end
# This sub serves as a cumulative "outer context" for code
# executed in HLL::Compiler's interactive REPL. It's invoked
# exactly once upon load/init to obtain a context, and its
# default LexPad is replaced with a Hash that we can use to
# cumulatively store outer context information. Both the
# context and hash are then made available via package
# variables.
.namespace []
.sub '&interactive_outer' :lex :init :load
.local pmc ctx, pad
$P0 = getinterp
ctx = $P0['context']
set_global ['HLL';'Compiler'], '$interactive_ctx', ctx
pad = getattribute ctx, 'lex_pad'
$P1 = new ['Hash']
copy pad, $P1
set_global ['HLL';'Compiler'], '%interactive_pad', pad
.end
### .include 'src/cheats/hll-grammar.pir'
# Copyright (C) 2009, The Perl Foundation.
=head1 TITLE
src/cheats/hll-grammar.pir -- Additional HLL::Grammar methods
=head2 Methods
=over 4
=cut
.include 'cclass.pasm'
### .include 'src/Regex/constants.pir'
.const int CURSOR_FAIL = -1
.const int CURSOR_FAIL_GROUP = -2
.const int CURSOR_FAIL_RULE = -3
.const int CURSOR_FAIL_MATCH = -4
.const int CURSOR_TYPE_SCAN = 1
.const int CURSOR_TYPE_PEEK = 2
.namespace ['HLL';'Grammar']
.sub '' :load :init
.local pmc brackets
brackets = box unicode:"<>[](){}\xab\xbb\u0f3a\u0f3b\u0f3c\u0f3d\u169b\u169c\u2045\u2046\u207d\u207e\u208d\u208e\u2329\u232a\u2768\u2769\u276a\u276b\u276c\u276d\u276e\u276f\u2770\u2771\u2772\u2773\u2774\u2775\u27c5\u27c6\u27e6\u27e7\u27e8\u27e9\u27ea\u27eb\u2983\u2984\u2985\u2986\u2987\u2988\u2989\u298a\u298b\u298c\u298d\u298e\u298f\u2990\u2991\u2992\u2993\u2994\u2995\u2996\u2997\u2998\u29d8\u29d9\u29da\u29db\u29fc\u29fd\u3008\u3009\u300a\u300b\u300c\u300d\u300e\u300f\u3010\u3011\u3014\u3015\u3016\u3017\u3018\u3019\u301a\u301b\u301d\u301e\ufd3e\ufd3f\ufe17\ufe18\ufe35\ufe36\ufe37\ufe38\ufe39\ufe3a\ufe3b\ufe3c\ufe3d\ufe3e\ufe3f\ufe40\ufe41\ufe42\ufe43\ufe44\ufe47\ufe48\ufe59\ufe5a\ufe5b\ufe5c\ufe5d\ufe5e\uff08\uff09\uff3b\uff3d\uff5b\uff5d\uff5f\uff60\uff62\uff63"
set_global '$!brackets', brackets
.end
.namespace ['HLL';'Grammar']
=item O(spec [, save])
This subrule attaches operator precedence information to
a match object (such as an operator token). A typical
invocation for the subrule might be:
token infix:sym<+> { <sym> <O( q{ %additive, :pirop<add> } )> }
This says to add all of the attribute of the C<%additive> hash
(described below) and a C<pirop> entry into the match object
returned by the C<< infix:sym<+> >> token (as the C<O> named
capture). Note that this is a alphabetic 'O", not a digit zero.
Currently the C<O> subrule accepts a string argument describing
the hash to be stored. (Note the C< q{ ... } > above. Eventually
it may be possible to omit the 'q' such that an actual (constant)
hash constructor is passed as an argument to C<O>.
The hash built via the string argument to C<O> is cached, so that
subsequent parses of the same token re-use the hash built from
previous parses of the token, rather than building a new hash
on each invocation.
The C<save> argument is used to build "hash" aggregates that can
be referred to by subsequent calls to C<O>. For example,
NQP::Grammar.O(':prec<t=>, :assoc<left>', '%additive' );
specifies the values to be associated with later references to
"%additive". Eventually it will likely be possible to use true
hashes from a package namespace, but this works for now.
Currently the only pairs recognized have the form C< :pair >,
C< :!pair >, and C<< :pair<strval> >>.
=cut
.sub 'O' :method
.param string spec
.param string save :optional
.param int has_save :opt_flag
# First, get the hash cache. Right now we have one
# cache for all grammars; eventually we may need a way to
# separate them out by cursor type.
.local pmc ohash
ohash = get_global '%!ohash'
unless null ohash goto have_ohash
ohash = new ['Hash']
set_global '%!ohash', ohash
have_ohash:
# See if we've already created a Hash for the current
# specification string -- if so, use that.
.local pmc hash
hash = ohash[spec]
unless null hash goto hash_done
# Otherwise, we need to build a new one.
hash = new ['Hash']
.local int pos, eos
pos = 0
eos = length spec
spec_loop:
pos = find_not_cclass .CCLASS_WHITESPACE, spec, pos, eos
if pos >= eos goto spec_done
$S0 = substr spec, pos, 1
if $S0 == ',' goto spec_comma
if $S0 == ':' goto spec_pair
# If whatever we found doesn't start with a colon, treat it
# as a lookup of a previously saved hash to be merged in.
.local string lookup
.local int lpos
# Find the first whitespace or comma
lpos = find_cclass .CCLASS_WHITESPACE, spec, pos, eos
$I0 = index spec, ',', pos
if $I0 < 0 goto have_lookup_lpos
if $I0 >= lpos goto have_lookup_lpos
lpos = $I0
have_lookup_lpos:
$I0 = lpos - pos
lookup = substr spec, pos, $I0
.local pmc lhash, lhash_it
lhash = ohash[lookup]
if null lhash goto err_lookup
lhash_it = iter lhash
lhash_loop:
unless lhash_it goto lhash_done
$S0 = shift lhash_it
$P0 = lhash[$S0]
hash[$S0] = $P0
goto lhash_loop
lhash_done:
pos = lpos
goto spec_loop
# We just ignore commas between elements for now.
spec_comma:
inc pos
goto spec_loop
# If we see a colon, then we want to parse whatever
# comes next like a pair.
spec_pair:
# eat colon
inc pos
.local string name
.local pmc value
value = new ['Boolean']
# If the pair is of the form :!name, then reverse the value
# and skip the colon.
$S0 = substr spec, pos, 1
$I0 = iseq $S0, '!'
pos += $I0
$I0 = not $I0
value = $I0
# Get the name of the pair.
lpos = find_not_cclass .CCLASS_WORD, spec, pos, eos
$I0 = lpos - pos
name = substr spec, pos, $I0
pos = lpos
# Look for a <...> that follows.
$S0 = substr spec, pos, 1
unless $S0 == '<' goto have_value
inc pos
lpos = index spec, '>', pos
$I0 = lpos - pos
$S0 = substr spec, pos, $I0
value = box $S0
pos = lpos + 1
have_value:
# Done processing the pair, store it in the hash.
hash[name] = value
goto spec_loop
spec_done:
# Done processing the spec string, cache the hash for later.
ohash[spec] = hash
hash_done:
# If we've been called as a subrule, then build a pass-cursor
# to indicate success and set the hash as the subrule's match object.
if has_save goto save_hash
($P0, $I0) = self.'!cursor_start'()
$P0.'!cursor_pass'($I0, '')
setattribute $P0, '$!match', hash
.return ($P0)
# save the hash under a new entry
save_hash:
ohash[save] = hash
.return (self)
err_lookup:
self.'panic'('Unknown operator precedence specification "', lookup, '"')
.end
=item panic([args :slurpy])
Throw an exception at the current cursor location. If the message
doesn't end with a newline, also output the line number and offset
of the match.
=cut
.sub 'panic' :method
.param pmc args :slurpy
.local int pos
.local pmc target
pos = self.'pos'()
target = getattribute self, '$!target'
$P0 = get_hll_global ['HLL'], 'Compiler'
$I1 = $P0.'lineof'(target, pos)
inc $I1
push args, ' at line '
push args, $I1
$S0 = target
$S0 = substr $S0, pos, 10
$S0 = escape $S0
push args, ', near "'
push args, $S0
push args, '"'
.local string message
message = join '', args
die message
.end
=item peek_delimiters(target, pos)
Return the start/stop delimiter pair based on peeking at C<target>
position C<pos>.
=cut
.sub 'peek_delimiters' :method
.param string target
.param int pos
.local string brackets, start, stop
$P0 = get_global '$!brackets'
brackets = $P0
# peek at the next character
start = substr target, pos, 1
# colon and word characters aren't valid delimiters
if start == ':' goto err_colon_delim
$I0 = is_cclass .CCLASS_WORD, start, 0
if $I0 goto err_word_delim
$I0 = is_cclass .CCLASS_WHITESPACE, start, 0
if $I0 goto err_ws_delim
# assume stop delim is same as start, for the moment
stop = start
# see if we have an opener or closer
$I0 = index brackets, start
if $I0 < 0 goto bracket_end
# if it's a closing bracket, that's an error also
$I1 = $I0 % 2
if $I1 goto err_close
# it's an opener, so get the closing bracket
inc $I0
stop = substr brackets, $I0, 1
# see if the opening bracket is repeated
.local int len
len = 0
bracket_loop:
inc pos
inc len
$S0 = substr target, pos, 1
if $S0 == start goto bracket_loop
if len == 1 goto bracket_end
start = repeat start, len
stop = repeat stop, len
bracket_end:
.return (start, stop, pos)
err_colon_delim:
self.'panic'('Colons may not be used to delimit quoting constructs')
err_word_delim:
self.'panic'('Alphanumeric character is not allowed as a delimiter')
err_ws_delim:
self.'panic'('Whitespace character is not allowed as a delimiter')
err_close:
self.'panic'('Use of a closing delimiter for an opener is reserved')
.end
.sub 'quote_EXPR' :method
.param pmc args :slurpy
.local pmc cur, debug
.local string target
.local int pos
(cur, pos, target) = self.'!cursor_start'()
debug = getattribute cur, '$!debug'
if null debug goto debug_1
cur.'!cursor_debug'('START', 'quote_EXPR')
debug_1:
.local pmc quotemod, true
.lex '%*QUOTEMOD', quotemod
quotemod = new ['Hash']
true = box 1
args_loop:
unless args goto args_done
.local string mod
mod = shift args
mod = substr mod, 1
quotemod[mod] = true
if mod == 'qq' goto opt_qq
if mod == 'b' goto opt_b
goto args_loop
opt_qq:
quotemod['s'] = true
quotemod['a'] = true
quotemod['h'] = true
quotemod['f'] = true
quotemod['c'] = true
quotemod['b'] = true
opt_b:
quotemod['q'] = true
goto args_loop
args_done:
.local pmc start, stop
(start, stop) = self.'peek_delimiters'(target, pos)
.lex '$*QUOTE_START', start
.lex '$*QUOTE_STOP', stop
$P10 = cur.'quote_delimited'()
unless $P10 goto fail
cur.'!mark_push'(0, CURSOR_FAIL, 0, $P10)
$P10.'!cursor_names'('quote_delimited')
pos = $P10.'pos'()
cur.'!cursor_pass'(pos, 'quote_EXPR')
if null debug goto done
cur.'!cursor_debug'('PASS', 'quote_EXPR')
goto done
fail:
if null debug goto done
cur.'!cursor_debug'('FAIL', 'quote_EXPR')
done:
.return (cur)
.end
.sub 'quotemod_check' :method :nsentry
.param string mod
$P0 = find_dynamic_lex '%*QUOTEMOD'
$P1 = $P0[mod]
unless null $P1 goto done
$P1 = new ['Undef']
done:
.return ($P1)
.end
.sub 'starter' :method
.local pmc cur
.local string target, start
.local int pos
(cur, pos, target) = self.'!cursor_start'()
$P0 = find_dynamic_lex '$*QUOTE_START'
if null $P0 goto fail
start = $P0
$I0 = length start
$S0 = substr target, pos, $I0
unless $S0 == start goto fail
pos += $I0
cur.'!cursor_pass'(pos, 'starter')
fail:
.return (cur)
.end
.sub 'stopper' :method
.local pmc cur
.local string target, stop
.local int pos
(cur, pos, target) = self.'!cursor_start'()
$P0 = find_dynamic_lex '$*QUOTE_STOP'
if null $P0 goto fail
stop = $P0
$I0 = length stop
$S0 = substr target, pos, $I0
unless $S0 == stop goto fail
pos += $I0
cur.'!cursor_pass'(pos, 'stopper')
fail:
.return (cur)
.end
.sub 'split_words' :method :nsentry
.param string words
.local int pos, eos
.local pmc result
pos = 0
eos = length words
result = new ['ResizablePMCArray']
split_loop:
pos = find_not_cclass .CCLASS_WHITESPACE, words, pos, eos
unless pos < eos goto split_done
$I0 = find_cclass .CCLASS_WHITESPACE, words, pos, eos
$I1 = $I0 - pos
$S0 = substr words, pos, $I1
push result, $S0
pos = $I0
goto split_loop
split_done:
.return (result)
.end
=item EXPR(...)
An operator precedence parser.
=cut
.sub 'EXPR' :method
.param string preclim :optional
.param int has_preclim :opt_flag
.local pmc here, pos, debug
(here, pos) = self.'!cursor_start'()
debug = getattribute here, '$!debug'
if null debug goto debug_1
here.'!cursor_debug'('START', 'EXPR')
debug_1:
if has_preclim goto have_preclim
preclim = ''
have_preclim:
.const 'Sub' reduce = 'EXPR_reduce'
.local string termishrx
termishrx = 'termish'
.local pmc opstack, termstack
opstack = new ['ResizablePMCArray']
.lex '@opstack', opstack
termstack = new ['ResizablePMCArray']
.lex '@termstack', termstack
term_loop:
here = here.termishrx()
unless here goto fail
.local pmc termish
termish = here.'MATCH'()
# interleave any prefix/postfix we might have found
.local pmc termOPER, prefixish, postfixish
termOPER = termish
termOPER_loop:
$I0 = exists termOPER['OPER']
unless $I0 goto termOPER_done
termOPER = termOPER['OPER']
goto termOPER_loop
termOPER_done:
prefixish = termOPER['prefixish']
postfixish = termOPER['postfixish']
if null prefixish goto prefix_done
prepostfix_loop:
unless prefixish goto prepostfix_done
unless postfixish goto prepostfix_done
.local pmc preO, postO
.local string preprec, postprec
$P0 = prefixish[0]
$P0 = $P0['OPER']
preO = $P0['O']
preprec = preO['prec']
$P0 = postfixish[-1]
$P0 = $P0['OPER']
postO = $P0['O']
postprec = postO['prec']
if postprec < preprec goto post_shift
if postprec > preprec goto pre_shift
$S0 = postO['uassoc']
if $S0 == 'right' goto pre_shift
post_shift:
$P0 = pop postfixish
push opstack, $P0
goto prepostfix_loop
pre_shift:
$P0 = shift prefixish
push opstack, $P0
goto prepostfix_loop
prepostfix_done:
prefix_loop:
unless prefixish goto prefix_done
$P0 = shift prefixish
push opstack, $P0
goto prefix_loop
prefix_done:
delete termish['prefixish']
postfix_loop:
if null postfixish goto postfix_done
unless postfixish goto postfix_done
$P0 = pop postfixish
push opstack, $P0
goto postfix_loop
postfix_done:
delete termish['postfixish']
$P0 = termish['term']
push termstack, $P0
# Now see if we can fetch an infix operator
.local pmc infixcur, infix
here = here.'ws'()
infixcur = here.'infixish'()
unless infixcur goto term_done
infix = infixcur.'MATCH'()
.local pmc inO
$P0 = infix['OPER']
inO = $P0['O']
termishrx = inO['nextterm']
if termishrx goto have_termishrx
termishrx = 'termish'
have_termishrx:
.local string inprec, inassoc, opprec
inprec = inO['prec']
unless inprec goto err_inprec
if inprec <= preclim goto term_done
inassoc = inO['assoc']
$P0 = inO['sub']
if null $P0 goto subprec_done
inO['prec'] = $P0
subprec_done:
reduce_loop:
unless opstack goto reduce_done
$P0 = opstack[-1]
$P0 = $P0['OPER']
$P0 = $P0['O']
opprec = $P0['prec']
unless opprec > inprec goto reduce_gt_done
capture_lex reduce
self.reduce(termstack, opstack)
goto reduce_loop
reduce_gt_done:
unless opprec == inprec goto reduce_done
# equal precedence, use associativity to decide
unless inassoc == 'left' goto reduce_done
# left associative, reduce immediately
capture_lex reduce
self.reduce(termstack, opstack)
reduce_done:
push opstack, infix # The Shift
here = infixcur.'ws'()
goto term_loop
term_done:
opstack_loop:
unless opstack goto opstack_done
capture_lex reduce
self.reduce(termstack, opstack)
goto opstack_loop
opstack_done:
expr_done:
.local pmc term
term = pop termstack
pos = here.'pos'()
here = self.'!cursor_start'()
setattribute here, '$!pos', pos
setattribute here, '$!match', term
here.'!reduce'('EXPR')
if null debug goto done
here.'!cursor_debug'('PASS', 'EXPR')
goto done
fail:
if null debug goto done
here.'!cursor_debug'('FAIL', 'EXPR')
done:
.return (here)
err_internal:
$I0 = termstack
here.'panic'('Internal operator parser error, @termstack == ', $I0)
err_inprec:
infixcur.'panic'('Missing infixish operator precedence')
.end
.sub 'EXPR_reduce' :method :anon
.param pmc termstack
.param pmc opstack
.local pmc op, opOPER, opO
.local string opassoc
op = pop opstack
opOPER = op['OPER']
opO = opOPER['O']
opassoc = opO['assoc']
if opassoc == 'unary' goto op_unary
if opassoc == 'list' goto op_list
op_infix:
.local pmc right, left
right = pop termstack
left = pop termstack
op[0] = left
op[1] = right
$S0 = opO['reducecheck']
unless $S0 goto op_infix_1
self.$S0(op)
op_infix_1:
self.'!reduce'('EXPR', 'INFIX', op)
goto done
op_unary:
.local pmc arg, afrom, ofrom
arg = pop termstack
op[0] = arg
afrom = arg.'from'()
ofrom = op.'from'()
if afrom < ofrom goto op_postfix
op_prefix:
self.'!reduce'('EXPR', 'PREFIX', op)
goto done
op_postfix:
self.'!reduce'('EXPR', 'POSTFIX', op)
goto done
op_list:
.local string sym
sym = opOPER['sym']
arg = pop termstack
unshift op, arg
op_sym_loop:
unless opstack goto op_sym_done
$P0 = opstack[-1]
$P0 = $P0['OPER']
$S0 = $P0['sym']
if sym != $S0 goto op_sym_done
arg = pop termstack
unshift op, arg
$P0 = pop opstack
goto op_sym_loop
op_sym_done:
arg = pop termstack
unshift op, arg
self.'!reduce'('EXPR', 'LIST', op)
goto done
done:
push termstack, op
.end
.sub 'ternary' :method
.param pmc match
$P0 = match[1]
$P1 = match['infix']
$P1 = $P1['EXPR']
match[1] = $P1
match[2] = $P0
.end
.sub 'MARKER' :method
.param pmc markname
.local pmc pos
pos = self.'pos'()
self.'!cursor_debug'('START', 'MARKER name=', markname, ', pos=', pos)
.local pmc markhash
markhash = get_global '%!MARKHASH'
unless null markhash goto have_markhash
markhash = new ['Hash']
set_global '%!MARKHASH', markhash
have_markhash:
markhash[markname] = pos
self.'!cursor_debug'('PASS', 'MARKER')
.return (1)
.end
.sub 'MARKED' :method
.param pmc markname
self.'!cursor_debug'('START','MARKED name=', markname)
.local pmc markhash
markhash = get_global '%!MARKHASH'
if null markhash goto fail
$P0 = markhash[markname]
if null $P0 goto fail
$P1 = self.'pos'()
unless $P0 == $P1 goto fail
self.'!cursor_debug'('PASS','MARKED')
.return (1)
fail:
self.'!cursor_debug'('FAIL','MARKED')
.return (0)
.end
.sub 'LANG' :method
.param string lang
.param string regex
.local pmc langhash, cur, pos
langhash = find_dynamic_lex '%*LANG'
$P0 = langhash[lang]
(cur, pos) = self.'!cursor_start'($P0)
cur.'!cursor_pos'(pos)
$S0 = concat lang, '-actions'
$P0 = langhash[$S0]
.lex '$*ACTIONS', $P0
# XXX can't use tailcall here or we lose $*ACTIONS
$P1 = cur.regex()
.return ($P1)
.end
=back
=cut
# Local Variables:
# mode: pir
# fill-column: 100
# End:
# vim: expandtab shiftwidth=4 ft=pir:
### .include 'src/cheats/parrot-callcontext.pir'
.namespace ['CallContext']
.sub 'lexpad_full' :method
.local pmc ctx, lexall, lexpad, lexpad_it
ctx = self
lexall = root_new ['parrot';'Hash']
context_loop:
if null ctx goto context_done
lexpad = getattribute ctx, 'lex_pad'
if null lexpad goto lexpad_done
lexpad_it = iter lexpad
lexpad_loop:
unless lexpad_it goto lexpad_done
$S0 = shift lexpad_it
$I0 = exists lexall[$S0]
if $I0 goto lexpad_loop
$P0 = lexpad[$S0]
lexall[$S0] = $P0
goto lexpad_loop
lexpad_done:
ctx = getattribute ctx, 'outer_ctx'
goto context_loop
context_done:
.return (lexall)
.end
### .include 'gen/hllgrammar-grammar.pir'
.namespace []
.sub "_block1000" :anon :subid("10_1308626174.53229")
.annotate 'line', 0
.const 'Sub' $P1003 = "11_1308626174.53229"
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', 5
.const 'Sub' $P1003 = "11_1308626174.53229"
capture_lex $P1003
$P101 = $P1003()
.annotate 'line', 1
.return ($P101)
.const 'Sub' $P1235 = "107_1308626174.53229"
.return ($P1235)
.end
.namespace []
.sub "" :load :init :subid("post108") :outer("10_1308626174.53229")
.annotate 'line', 0
.const 'Sub' $P1001 = "10_1308626174.53229"
.local pmc block
set block, $P1001
$P1237 = get_root_global ["parrot"], "P6metaclass"
$P1237."new_class"("HLL::Grammar", "Regex::Cursor" :named("parent"))
.end
.namespace ["HLL";"Grammar"]
.sub "_block1002" :subid("11_1308626174.53229") :outer("10_1308626174.53229")
.annotate 'line', 5
.const 'Sub' $P1223 = "103_1308626174.53229"
capture_lex $P1223
.const 'Sub' $P1218 = "101_1308626174.53229"
capture_lex $P1218
.const 'Sub' $P1207 = "98_1308626174.53229"
capture_lex $P1207
.const 'Sub' $P1190 = "93_1308626174.53229"
capture_lex $P1190
.const 'Sub' $P1185 = "91_1308626174.53229"
capture_lex $P1185
.const 'Sub' $P1181 = "89_1308626174.53229"
capture_lex $P1181
.const 'Sub' $P1176 = "87_1308626174.53229"
capture_lex $P1176
.const 'Sub' $P1171 = "85_1308626174.53229"
capture_lex $P1171
.const 'Sub' $P1167 = "83_1308626174.53229"
capture_lex $P1167
.const 'Sub' $P1163 = "81_1308626174.53229"
capture_lex $P1163
.const 'Sub' $P1159 = "79_1308626174.53229"
capture_lex $P1159
.const 'Sub' $P1155 = "77_1308626174.53229"
capture_lex $P1155
.const 'Sub' $P1151 = "75_1308626174.53229"
capture_lex $P1151
.const 'Sub' $P1147 = "73_1308626174.53229"
capture_lex $P1147
.const 'Sub' $P1143 = "71_1308626174.53229"
capture_lex $P1143
.const 'Sub' $P1139 = "69_1308626174.53229"
capture_lex $P1139
.const 'Sub' $P1132 = "65_1308626174.53229"
capture_lex $P1132
.const 'Sub' $P1120 = "63_1308626174.53229"
capture_lex $P1120
.const 'Sub' $P1114 = "61_1308626174.53229"
capture_lex $P1114
.const 'Sub' $P1109 = "59_1308626174.53229"
capture_lex $P1109
.const 'Sub' $P1103 = "57_1308626174.53229"
capture_lex $P1103
.const 'Sub' $P1098 = "55_1308626174.53229"
capture_lex $P1098
.const 'Sub' $P1092 = "53_1308626174.53229"
capture_lex $P1092
.const 'Sub' $P1087 = "51_1308626174.53229"
capture_lex $P1087
.const 'Sub' $P1081 = "49_1308626174.53229"
capture_lex $P1081
.const 'Sub' $P1076 = "47_1308626174.53229"
capture_lex $P1076
.const 'Sub' $P1071 = "45_1308626174.53229"
capture_lex $P1071
.const 'Sub' $P1065 = "43_1308626174.53229"
capture_lex $P1065
.const 'Sub' $P1059 = "41_1308626174.53229"
capture_lex $P1059
.const 'Sub' $P1055 = "40_1308626174.53229"
capture_lex $P1055
.const 'Sub' $P1051 = "38_1308626174.53229"
capture_lex $P1051
.const 'Sub' $P1047 = "36_1308626174.53229"
capture_lex $P1047
.const 'Sub' $P1042 = "34_1308626174.53229"
capture_lex $P1042
.const 'Sub' $P1038 = "32_1308626174.53229"
capture_lex $P1038
.const 'Sub' $P1034 = "30_1308626174.53229"
capture_lex $P1034
.const 'Sub' $P1030 = "28_1308626174.53229"
capture_lex $P1030
.const 'Sub' $P1010 = "14_1308626174.53229"
capture_lex $P1010
.const 'Sub' $P1004 = "12_1308626174.53229"
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' $P1223 = "103_1308626174.53229"
capture_lex $P1223
.return ($P1223)
.const 'Sub' $P1232 = "106_1308626174.53229"
.return ($P1232)
.end
.namespace ["HLL";"Grammar"]
.sub "ws" :subid("12_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1005_tgt
.local int rx1005_pos
.local int rx1005_off
.local int rx1005_eos
.local int rx1005_rep
.local pmc rx1005_cur
.local pmc rx1005_debug
(rx1005_cur, rx1005_pos, rx1005_tgt, $I10) = self."!cursor_start"()
getattribute rx1005_debug, rx1005_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1005_cur
.local pmc match
.lex "$/", match
length rx1005_eos, rx1005_tgt
gt rx1005_pos, rx1005_eos, rx1005_done
set rx1005_off, 0
lt rx1005_pos, 2, rx1005_start
sub rx1005_off, rx1005_pos, 1
substr rx1005_tgt, rx1005_tgt, rx1005_off
rx1005_start:
eq $I10, 1, rx1005_restart
if_null rx1005_debug, debug_109
rx1005_cur."!cursor_debug"("START", "ws")
debug_109:
$I10 = self.'from'()
ne $I10, -1, rxscan1007_done
goto rxscan1007_scan
rxscan1007_loop:
($P10) = rx1005_cur."from"()
inc $P10
set rx1005_pos, $P10
ge rx1005_pos, rx1005_eos, rxscan1007_done
rxscan1007_scan:
set_addr $I10, rxscan1007_loop
rx1005_cur."!mark_push"(0, rx1005_pos, $I10)
rxscan1007_done:
# rx subrule "ww" subtype=zerowidth negate=1
rx1005_cur."!cursor_pos"(rx1005_pos)
$P10 = rx1005_cur."ww"()
if $P10, rx1005_fail
# rx rxquantr1008 ** 0..*
set_addr $I10, rxquantr1008_done
rx1005_cur."!mark_push"(0, rx1005_pos, $I10)
rxquantr1008_loop:
alt1009_0:
set_addr $I10, alt1009_1
rx1005_cur."!mark_push"(0, rx1005_pos, $I10)
# rx charclass_q s r 1..-1
sub $I10, rx1005_pos, rx1005_off
find_not_cclass $I11, 32, rx1005_tgt, $I10, rx1005_eos
add $I12, $I10, 1
lt $I11, $I12, rx1005_fail
add rx1005_pos, rx1005_off, $I11
goto alt1009_end
alt1009_1:
# rx literal "#"
add $I11, rx1005_pos, 1
gt $I11, rx1005_eos, rx1005_fail
sub $I11, rx1005_pos, rx1005_off
ord $I11, rx1005_tgt, $I11
ne $I11, 35, rx1005_fail
add rx1005_pos, 1
# rx charclass_q N r 0..-1
sub $I10, rx1005_pos, rx1005_off
find_cclass $I11, 4096, rx1005_tgt, $I10, rx1005_eos
add rx1005_pos, rx1005_off, $I11
alt1009_end:
set_addr $I10, rxquantr1008_done
(rx1005_rep) = rx1005_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1008_done
rx1005_cur."!mark_push"(rx1005_rep, rx1005_pos, $I10)
goto rxquantr1008_loop
rxquantr1008_done:
# rx pass
rx1005_cur."!cursor_pass"(rx1005_pos, "ws")
if_null rx1005_debug, debug_110
rx1005_cur."!cursor_debug"("PASS", "ws", " at pos=", rx1005_pos)
debug_110:
.return (rx1005_cur)
rx1005_restart:
if_null rx1005_debug, debug_111
rx1005_cur."!cursor_debug"("NEXT", "ws")
debug_111:
rx1005_fail:
(rx1005_rep, rx1005_pos, $I10, $P10) = rx1005_cur."!mark_fail"(0)
lt rx1005_pos, -1, rx1005_done
eq rx1005_pos, -1, rx1005_fail
jump $I10
rx1005_done:
rx1005_cur."!cursor_fail"()
if_null rx1005_debug, debug_112
rx1005_cur."!cursor_debug"("FAIL", "ws")
debug_112:
.return (rx1005_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__ws" :subid("13_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "termish" :subid("14_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.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"()
rx1011_cur."!cursor_caparray"("prefixish", "postfixish")
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_113
rx1011_cur."!cursor_debug"("START", "termish")
debug_113:
$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:
# rx subrule "prefixish" subtype=capture negate=
rx1011_cur."!cursor_pos"(rx1011_pos)
$P10 = rx1011_cur."prefixish"()
unless $P10, rx1011_fail
goto rxsubrule1015_pass
rxsubrule1015_back:
$P10 = $P10."!cursor_next"()
unless $P10, rx1011_fail
rxsubrule1015_pass:
set_addr $I10, rxsubrule1015_back
rx1011_cur."!mark_push"(0, rx1011_pos, $I10, $P10)
$P10."!cursor_names"("prefixish")
rx1011_pos = $P10."pos"()
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:
.annotate 'line', 9
# rx subrule "term" subtype=capture negate=
rx1011_cur."!cursor_pos"(rx1011_pos)
$P10 = rx1011_cur."term"()
unless $P10, rx1011_fail
rx1011_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("term")
rx1011_pos = $P10."pos"()
.annotate 'line', 10
# rx rxquantr1016 ** 0..*
set_addr $I10, rxquantr1016_done
rx1011_cur."!mark_push"(0, rx1011_pos, $I10)
rxquantr1016_loop:
# rx subrule "postfixish" subtype=capture negate=
rx1011_cur."!cursor_pos"(rx1011_pos)
$P10 = rx1011_cur."postfixish"()
unless $P10, rx1011_fail
goto rxsubrule1017_pass
rxsubrule1017_back:
$P10 = $P10."!cursor_next"()
unless $P10, rx1011_fail
rxsubrule1017_pass:
set_addr $I10, rxsubrule1017_back
rx1011_cur."!mark_push"(0, rx1011_pos, $I10, $P10)
$P10."!cursor_names"("postfixish")
rx1011_pos = $P10."pos"()
set_addr $I10, rxquantr1016_done
(rx1011_rep) = rx1011_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1016_done
rx1011_cur."!mark_push"(rx1011_rep, rx1011_pos, $I10)
goto rxquantr1016_loop
rxquantr1016_done:
.annotate 'line', 7
# rx pass
rx1011_cur."!cursor_pass"(rx1011_pos, "termish")
if_null rx1011_debug, debug_114
rx1011_cur."!cursor_debug"("PASS", "termish", " at pos=", rx1011_pos)
debug_114:
.return (rx1011_cur)
rx1011_restart:
.annotate 'line', 5
if_null rx1011_debug, debug_115
rx1011_cur."!cursor_debug"("NEXT", "termish")
debug_115:
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_116
rx1011_cur."!cursor_debug"("FAIL", "termish")
debug_116:
.return (rx1011_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__termish" :subid("15_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "term" :subid("16_1308626174.53229") :method
.annotate 'line', 13
$P100 = self."!protoregex"("term")
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__term" :subid("17_1308626174.53229") :method
.annotate 'line', 13
$P101 = self."!PREFIX__!protoregex"("term")
.return ($P101)
.end
.namespace ["HLL";"Grammar"]
.sub "infix" :subid("18_1308626174.53229") :method
.annotate 'line', 14
$P100 = self."!protoregex"("infix")
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__infix" :subid("19_1308626174.53229") :method
.annotate 'line', 14
$P101 = self."!PREFIX__!protoregex"("infix")
.return ($P101)
.end
.namespace ["HLL";"Grammar"]
.sub "prefix" :subid("20_1308626174.53229") :method
.annotate 'line', 15
$P100 = self."!protoregex"("prefix")
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__prefix" :subid("21_1308626174.53229") :method
.annotate 'line', 15
$P101 = self."!PREFIX__!protoregex"("prefix")
.return ($P101)
.end
.namespace ["HLL";"Grammar"]
.sub "postfix" :subid("22_1308626174.53229") :method
.annotate 'line', 16
$P100 = self."!protoregex"("postfix")
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__postfix" :subid("23_1308626174.53229") :method
.annotate 'line', 16
$P101 = self."!PREFIX__!protoregex"("postfix")
.return ($P101)
.end
.namespace ["HLL";"Grammar"]
.sub "circumfix" :subid("24_1308626174.53229") :method
.annotate 'line', 17
$P100 = self."!protoregex"("circumfix")
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__circumfix" :subid("25_1308626174.53229") :method
.annotate 'line', 17
$P101 = self."!PREFIX__!protoregex"("circumfix")
.return ($P101)
.end
.namespace ["HLL";"Grammar"]
.sub "postcircumfix" :subid("26_1308626174.53229") :method
.annotate 'line', 18
$P100 = self."!protoregex"("postcircumfix")
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__postcircumfix" :subid("27_1308626174.53229") :method
.annotate 'line', 18
$P101 = self."!PREFIX__!protoregex"("postcircumfix")
.return ($P101)
.end
.namespace ["HLL";"Grammar"]
.sub "term:sym<circumfix>" :subid("28_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.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_117
rx1031_cur."!cursor_debug"("START", "term:sym<circumfix>")
debug_117:
$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:
.annotate 'line', 20
# rx subrule "circumfix" subtype=capture negate=
rx1031_cur."!cursor_pos"(rx1031_pos)
$P10 = rx1031_cur."circumfix"()
unless $P10, rx1031_fail
rx1031_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("circumfix")
rx1031_pos = $P10."pos"()
# rx pass
rx1031_cur."!cursor_pass"(rx1031_pos, "term:sym<circumfix>")
if_null rx1031_debug, debug_118
rx1031_cur."!cursor_debug"("PASS", "term:sym<circumfix>", " at pos=", rx1031_pos)
debug_118:
.return (rx1031_cur)
rx1031_restart:
.annotate 'line', 5
if_null rx1031_debug, debug_119
rx1031_cur."!cursor_debug"("NEXT", "term:sym<circumfix>")
debug_119:
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_120
rx1031_cur."!cursor_debug"("FAIL", "term:sym<circumfix>")
debug_120:
.return (rx1031_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__term:sym<circumfix>" :subid("29_1308626174.53229") :method
.annotate 'line', 5
$P100 = self."!PREFIX__!subrule"("circumfix", "")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["HLL";"Grammar"]
.sub "infixish" :subid("30_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1035_tgt
.local int rx1035_pos
.local int rx1035_off
.local int rx1035_eos
.local int rx1035_rep
.local pmc rx1035_cur
.local pmc rx1035_debug
(rx1035_cur, rx1035_pos, rx1035_tgt, $I10) = self."!cursor_start"()
getattribute rx1035_debug, rx1035_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1035_cur
.local pmc match
.lex "$/", match
length rx1035_eos, rx1035_tgt
gt rx1035_pos, rx1035_eos, rx1035_done
set rx1035_off, 0
lt rx1035_pos, 2, rx1035_start
sub rx1035_off, rx1035_pos, 1
substr rx1035_tgt, rx1035_tgt, rx1035_off
rx1035_start:
eq $I10, 1, rx1035_restart
if_null rx1035_debug, debug_121
rx1035_cur."!cursor_debug"("START", "infixish")
debug_121:
$I10 = self.'from'()
ne $I10, -1, rxscan1037_done
goto rxscan1037_scan
rxscan1037_loop:
($P10) = rx1035_cur."from"()
inc $P10
set rx1035_pos, $P10
ge rx1035_pos, rx1035_eos, rxscan1037_done
rxscan1037_scan:
set_addr $I10, rxscan1037_loop
rx1035_cur."!mark_push"(0, rx1035_pos, $I10)
rxscan1037_done:
.annotate 'line', 22
# rx subrule "infix" subtype=capture negate=
rx1035_cur."!cursor_pos"(rx1035_pos)
$P10 = rx1035_cur."infix"()
unless $P10, rx1035_fail
rx1035_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("OPER=infix")
rx1035_pos = $P10."pos"()
# rx pass
rx1035_cur."!cursor_pass"(rx1035_pos, "infixish")
if_null rx1035_debug, debug_122
rx1035_cur."!cursor_debug"("PASS", "infixish", " at pos=", rx1035_pos)
debug_122:
.return (rx1035_cur)
rx1035_restart:
.annotate 'line', 5
if_null rx1035_debug, debug_123
rx1035_cur."!cursor_debug"("NEXT", "infixish")
debug_123:
rx1035_fail:
(rx1035_rep, rx1035_pos, $I10, $P10) = rx1035_cur."!mark_fail"(0)
lt rx1035_pos, -1, rx1035_done
eq rx1035_pos, -1, rx1035_fail
jump $I10
rx1035_done:
rx1035_cur."!cursor_fail"()
if_null rx1035_debug, debug_124
rx1035_cur."!cursor_debug"("FAIL", "infixish")
debug_124:
.return (rx1035_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__infixish" :subid("31_1308626174.53229") :method
.annotate 'line', 5
$P100 = self."!PREFIX__!subrule"("infix", "")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["HLL";"Grammar"]
.sub "prefixish" :subid("32_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1039_tgt
.local int rx1039_pos
.local int rx1039_off
.local int rx1039_eos
.local int rx1039_rep
.local pmc rx1039_cur
.local pmc rx1039_debug
(rx1039_cur, rx1039_pos, rx1039_tgt, $I10) = self."!cursor_start"()
getattribute rx1039_debug, rx1039_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1039_cur
.local pmc match
.lex "$/", match
length rx1039_eos, rx1039_tgt
gt rx1039_pos, rx1039_eos, rx1039_done
set rx1039_off, 0
lt rx1039_pos, 2, rx1039_start
sub rx1039_off, rx1039_pos, 1
substr rx1039_tgt, rx1039_tgt, rx1039_off
rx1039_start:
eq $I10, 1, rx1039_restart
if_null rx1039_debug, debug_125
rx1039_cur."!cursor_debug"("START", "prefixish")
debug_125:
$I10 = self.'from'()
ne $I10, -1, rxscan1041_done
goto rxscan1041_scan
rxscan1041_loop:
($P10) = rx1039_cur."from"()
inc $P10
set rx1039_pos, $P10
ge rx1039_pos, rx1039_eos, rxscan1041_done
rxscan1041_scan:
set_addr $I10, rxscan1041_loop
rx1039_cur."!mark_push"(0, rx1039_pos, $I10)
rxscan1041_done:
.annotate 'line', 23
# rx subrule "prefix" subtype=capture negate=
rx1039_cur."!cursor_pos"(rx1039_pos)
$P10 = rx1039_cur."prefix"()
unless $P10, rx1039_fail
rx1039_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("OPER=prefix")
rx1039_pos = $P10."pos"()
# rx subrule "ws" subtype=method negate=
rx1039_cur."!cursor_pos"(rx1039_pos)
$P10 = rx1039_cur."ws"()
unless $P10, rx1039_fail
rx1039_pos = $P10."pos"()
# rx pass
rx1039_cur."!cursor_pass"(rx1039_pos, "prefixish")
if_null rx1039_debug, debug_126
rx1039_cur."!cursor_debug"("PASS", "prefixish", " at pos=", rx1039_pos)
debug_126:
.return (rx1039_cur)
rx1039_restart:
.annotate 'line', 5
if_null rx1039_debug, debug_127
rx1039_cur."!cursor_debug"("NEXT", "prefixish")
debug_127:
rx1039_fail:
(rx1039_rep, rx1039_pos, $I10, $P10) = rx1039_cur."!mark_fail"(0)
lt rx1039_pos, -1, rx1039_done
eq rx1039_pos, -1, rx1039_fail
jump $I10
rx1039_done:
rx1039_cur."!cursor_fail"()
if_null rx1039_debug, debug_128
rx1039_cur."!cursor_debug"("FAIL", "prefixish")
debug_128:
.return (rx1039_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__prefixish" :subid("33_1308626174.53229") :method
.annotate 'line', 5
$P100 = self."!PREFIX__!subrule"("prefix", "")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["HLL";"Grammar"]
.sub "postfixish" :subid("34_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1043_tgt
.local int rx1043_pos
.local int rx1043_off
.local int rx1043_eos
.local int rx1043_rep
.local pmc rx1043_cur
.local pmc rx1043_debug
(rx1043_cur, rx1043_pos, rx1043_tgt, $I10) = self."!cursor_start"()
getattribute rx1043_debug, rx1043_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1043_cur
.local pmc match
.lex "$/", match
length rx1043_eos, rx1043_tgt
gt rx1043_pos, rx1043_eos, rx1043_done
set rx1043_off, 0
lt rx1043_pos, 2, rx1043_start
sub rx1043_off, rx1043_pos, 1
substr rx1043_tgt, rx1043_tgt, rx1043_off
rx1043_start:
eq $I10, 1, rx1043_restart
if_null rx1043_debug, debug_129
rx1043_cur."!cursor_debug"("START", "postfixish")
debug_129:
$I10 = self.'from'()
ne $I10, -1, rxscan1045_done
goto rxscan1045_scan
rxscan1045_loop:
($P10) = rx1043_cur."from"()
inc $P10
set rx1043_pos, $P10
ge rx1043_pos, rx1043_eos, rxscan1045_done
rxscan1045_scan:
set_addr $I10, rxscan1045_loop
rx1043_cur."!mark_push"(0, rx1043_pos, $I10)
rxscan1045_done:
alt1046_0:
.annotate 'line', 24
set_addr $I10, alt1046_1
rx1043_cur."!mark_push"(0, rx1043_pos, $I10)
.annotate 'line', 25
# rx subrule "postfix" subtype=capture negate=
rx1043_cur."!cursor_pos"(rx1043_pos)
$P10 = rx1043_cur."postfix"()
unless $P10, rx1043_fail
rx1043_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("OPER=postfix")
rx1043_pos = $P10."pos"()
goto alt1046_end
alt1046_1:
.annotate 'line', 26
# rx subrule "postcircumfix" subtype=capture negate=
rx1043_cur."!cursor_pos"(rx1043_pos)
$P10 = rx1043_cur."postcircumfix"()
unless $P10, rx1043_fail
rx1043_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("OPER=postcircumfix")
rx1043_pos = $P10."pos"()
alt1046_end:
.annotate 'line', 24
# rx pass
rx1043_cur."!cursor_pass"(rx1043_pos, "postfixish")
if_null rx1043_debug, debug_130
rx1043_cur."!cursor_debug"("PASS", "postfixish", " at pos=", rx1043_pos)
debug_130:
.return (rx1043_cur)
rx1043_restart:
.annotate 'line', 5
if_null rx1043_debug, debug_131
rx1043_cur."!cursor_debug"("NEXT", "postfixish")
debug_131:
rx1043_fail:
(rx1043_rep, rx1043_pos, $I10, $P10) = rx1043_cur."!mark_fail"(0)
lt rx1043_pos, -1, rx1043_done
eq rx1043_pos, -1, rx1043_fail
jump $I10
rx1043_done:
rx1043_cur."!cursor_fail"()
if_null rx1043_debug, debug_132
rx1043_cur."!cursor_debug"("FAIL", "postfixish")
debug_132:
.return (rx1043_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__postfixish" :subid("35_1308626174.53229") :method
.annotate 'line', 5
$P100 = self."!PREFIX__!subrule"("postcircumfix", "")
$P101 = self."!PREFIX__!subrule"("postfix", "")
new $P102, "ResizablePMCArray"
push $P102, $P100
push $P102, $P101
.return ($P102)
.end
.namespace ["HLL";"Grammar"]
.sub "nullterm" :subid("36_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1048_tgt
.local int rx1048_pos
.local int rx1048_off
.local int rx1048_eos
.local int rx1048_rep
.local pmc rx1048_cur
.local pmc rx1048_debug
(rx1048_cur, rx1048_pos, rx1048_tgt, $I10) = self."!cursor_start"()
getattribute rx1048_debug, rx1048_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1048_cur
.local pmc match
.lex "$/", match
length rx1048_eos, rx1048_tgt
gt rx1048_pos, rx1048_eos, rx1048_done
set rx1048_off, 0
lt rx1048_pos, 2, rx1048_start
sub rx1048_off, rx1048_pos, 1
substr rx1048_tgt, rx1048_tgt, rx1048_off
rx1048_start:
eq $I10, 1, rx1048_restart
if_null rx1048_debug, debug_133
rx1048_cur."!cursor_debug"("START", "nullterm")
debug_133:
$I10 = self.'from'()
ne $I10, -1, rxscan1050_done
goto rxscan1050_scan
rxscan1050_loop:
($P10) = rx1048_cur."from"()
inc $P10
set rx1048_pos, $P10
ge rx1048_pos, rx1048_eos, rxscan1050_done
rxscan1050_scan:
set_addr $I10, rxscan1050_loop
rx1048_cur."!mark_push"(0, rx1048_pos, $I10)
rxscan1050_done:
.annotate 'line', 29
# rx pass
rx1048_cur."!cursor_pass"(rx1048_pos, "nullterm")
if_null rx1048_debug, debug_134
rx1048_cur."!cursor_debug"("PASS", "nullterm", " at pos=", rx1048_pos)
debug_134:
.return (rx1048_cur)
rx1048_restart:
.annotate 'line', 5
if_null rx1048_debug, debug_135
rx1048_cur."!cursor_debug"("NEXT", "nullterm")
debug_135:
rx1048_fail:
(rx1048_rep, rx1048_pos, $I10, $P10) = rx1048_cur."!mark_fail"(0)
lt rx1048_pos, -1, rx1048_done
eq rx1048_pos, -1, rx1048_fail
jump $I10
rx1048_done:
rx1048_cur."!cursor_fail"()
if_null rx1048_debug, debug_136
rx1048_cur."!cursor_debug"("FAIL", "nullterm")
debug_136:
.return (rx1048_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__nullterm" :subid("37_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "nullterm_alt" :subid("38_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1052_tgt
.local int rx1052_pos
.local int rx1052_off
.local int rx1052_eos
.local int rx1052_rep
.local pmc rx1052_cur
.local pmc rx1052_debug
(rx1052_cur, rx1052_pos, rx1052_tgt, $I10) = self."!cursor_start"()
getattribute rx1052_debug, rx1052_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1052_cur
.local pmc match
.lex "$/", match
length rx1052_eos, rx1052_tgt
gt rx1052_pos, rx1052_eos, rx1052_done
set rx1052_off, 0
lt rx1052_pos, 2, rx1052_start
sub rx1052_off, rx1052_pos, 1
substr rx1052_tgt, rx1052_tgt, rx1052_off
rx1052_start:
eq $I10, 1, rx1052_restart
if_null rx1052_debug, debug_137
rx1052_cur."!cursor_debug"("START", "nullterm_alt")
debug_137:
$I10 = self.'from'()
ne $I10, -1, rxscan1054_done
goto rxscan1054_scan
rxscan1054_loop:
($P10) = rx1052_cur."from"()
inc $P10
set rx1052_pos, $P10
ge rx1052_pos, rx1052_eos, rxscan1054_done
rxscan1054_scan:
set_addr $I10, rxscan1054_loop
rx1052_cur."!mark_push"(0, rx1052_pos, $I10)
rxscan1054_done:
.annotate 'line', 30
# rx subrule "nullterm" subtype=capture negate=
rx1052_cur."!cursor_pos"(rx1052_pos)
$P10 = rx1052_cur."nullterm"()
unless $P10, rx1052_fail
rx1052_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("term")
rx1052_pos = $P10."pos"()
# rx pass
rx1052_cur."!cursor_pass"(rx1052_pos, "nullterm_alt")
if_null rx1052_debug, debug_138
rx1052_cur."!cursor_debug"("PASS", "nullterm_alt", " at pos=", rx1052_pos)
debug_138:
.return (rx1052_cur)
rx1052_restart:
.annotate 'line', 5
if_null rx1052_debug, debug_139
rx1052_cur."!cursor_debug"("NEXT", "nullterm_alt")
debug_139:
rx1052_fail:
(rx1052_rep, rx1052_pos, $I10, $P10) = rx1052_cur."!mark_fail"(0)
lt rx1052_pos, -1, rx1052_done
eq rx1052_pos, -1, rx1052_fail
jump $I10
rx1052_done:
rx1052_cur."!cursor_fail"()
if_null rx1052_debug, debug_140
rx1052_cur."!cursor_debug"("FAIL", "nullterm_alt")
debug_140:
.return (rx1052_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__nullterm_alt" :subid("39_1308626174.53229") :method
.annotate 'line', 5
$P100 = self."!PREFIX__!subrule"("nullterm", "")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["HLL";"Grammar"]
.include "except_types.pasm"
.sub "nulltermish" :subid("40_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 33
new $P1057, ['ExceptionHandler'], .CONTROL_RETURN
set_label $P1057, control_1056
push_eh $P1057
.lex "self", self
find_lex $P101, "self"
$P102 = $P101."termish"()
unless $P102, unless_1058
set $P100, $P102
goto unless_1058_end
unless_1058:
find_lex $P103, "self"
$P104 = $P103."nullterm_alt"()
set $P100, $P104
unless_1058_end:
.return ($P100)
control_1056:
.local pmc exception
.get_results (exception)
getattribute $P101, exception, "payload"
.return ($P101)
.end
.namespace ["HLL";"Grammar"]
.sub "quote_delimited" :subid("41_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1060_tgt
.local int rx1060_pos
.local int rx1060_off
.local int rx1060_eos
.local int rx1060_rep
.local pmc rx1060_cur
.local pmc rx1060_debug
(rx1060_cur, rx1060_pos, rx1060_tgt, $I10) = self."!cursor_start"()
rx1060_cur."!cursor_caparray"("quote_atom")
getattribute rx1060_debug, rx1060_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1060_cur
.local pmc match
.lex "$/", match
length rx1060_eos, rx1060_tgt
gt rx1060_pos, rx1060_eos, rx1060_done
set rx1060_off, 0
lt rx1060_pos, 2, rx1060_start
sub rx1060_off, rx1060_pos, 1
substr rx1060_tgt, rx1060_tgt, rx1060_off
rx1060_start:
eq $I10, 1, rx1060_restart
if_null rx1060_debug, debug_141
rx1060_cur."!cursor_debug"("START", "quote_delimited")
debug_141:
$I10 = self.'from'()
ne $I10, -1, rxscan1062_done
goto rxscan1062_scan
rxscan1062_loop:
($P10) = rx1060_cur."from"()
inc $P10
set rx1060_pos, $P10
ge rx1060_pos, rx1060_eos, rxscan1062_done
rxscan1062_scan:
set_addr $I10, rxscan1062_loop
rx1060_cur."!mark_push"(0, rx1060_pos, $I10)
rxscan1062_done:
.annotate 'line', 37
# rx subrule "starter" subtype=capture negate=
rx1060_cur."!cursor_pos"(rx1060_pos)
$P10 = rx1060_cur."starter"()
unless $P10, rx1060_fail
rx1060_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("starter")
rx1060_pos = $P10."pos"()
# rx rxquantr1063 ** 0..*
set_addr $I10, rxquantr1063_done
rx1060_cur."!mark_push"(0, rx1060_pos, $I10)
rxquantr1063_loop:
# rx subrule "quote_atom" subtype=capture negate=
rx1060_cur."!cursor_pos"(rx1060_pos)
$P10 = rx1060_cur."quote_atom"()
unless $P10, rx1060_fail
goto rxsubrule1064_pass
rxsubrule1064_back:
$P10 = $P10."!cursor_next"()
unless $P10, rx1060_fail
rxsubrule1064_pass:
set_addr $I10, rxsubrule1064_back
rx1060_cur."!mark_push"(0, rx1060_pos, $I10, $P10)
$P10."!cursor_names"("quote_atom")
rx1060_pos = $P10."pos"()
set_addr $I10, rxquantr1063_done
(rx1060_rep) = rx1060_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1063_done
rx1060_cur."!mark_push"(rx1060_rep, rx1060_pos, $I10)
goto rxquantr1063_loop
rxquantr1063_done:
# rx subrule "stopper" subtype=capture negate=
rx1060_cur."!cursor_pos"(rx1060_pos)
$P10 = rx1060_cur."stopper"()
unless $P10, rx1060_fail
rx1060_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("stopper")
rx1060_pos = $P10."pos"()
.annotate 'line', 36
# rx pass
rx1060_cur."!cursor_pass"(rx1060_pos, "quote_delimited")
if_null rx1060_debug, debug_142
rx1060_cur."!cursor_debug"("PASS", "quote_delimited", " at pos=", rx1060_pos)
debug_142:
.return (rx1060_cur)
rx1060_restart:
.annotate 'line', 5
if_null rx1060_debug, debug_143
rx1060_cur."!cursor_debug"("NEXT", "quote_delimited")
debug_143:
rx1060_fail:
(rx1060_rep, rx1060_pos, $I10, $P10) = rx1060_cur."!mark_fail"(0)
lt rx1060_pos, -1, rx1060_done
eq rx1060_pos, -1, rx1060_fail
jump $I10
rx1060_done:
rx1060_cur."!cursor_fail"()
if_null rx1060_debug, debug_144
rx1060_cur."!cursor_debug"("FAIL", "quote_delimited")
debug_144:
.return (rx1060_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__quote_delimited" :subid("42_1308626174.53229") :method
.annotate 'line', 5
$P100 = self."!PREFIX__!subrule"("starter", "")
new $P101, "ResizablePMCArray"
push $P101, $P100
.return ($P101)
.end
.namespace ["HLL";"Grammar"]
.sub "quote_atom" :subid("43_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1066_tgt
.local int rx1066_pos
.local int rx1066_off
.local int rx1066_eos
.local int rx1066_rep
.local pmc rx1066_cur
.local pmc rx1066_debug
(rx1066_cur, rx1066_pos, rx1066_tgt, $I10) = self."!cursor_start"()
getattribute rx1066_debug, rx1066_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1066_cur
.local pmc match
.lex "$/", match
length rx1066_eos, rx1066_tgt
gt rx1066_pos, rx1066_eos, rx1066_done
set rx1066_off, 0
lt rx1066_pos, 2, rx1066_start
sub rx1066_off, rx1066_pos, 1
substr rx1066_tgt, rx1066_tgt, rx1066_off
rx1066_start:
eq $I10, 1, rx1066_restart
if_null rx1066_debug, debug_145
rx1066_cur."!cursor_debug"("START", "quote_atom")
debug_145:
$I10 = self.'from'()
ne $I10, -1, rxscan1068_done
goto rxscan1068_scan
rxscan1068_loop:
($P10) = rx1066_cur."from"()
inc $P10
set rx1066_pos, $P10
ge rx1066_pos, rx1066_eos, rxscan1068_done
rxscan1068_scan:
set_addr $I10, rxscan1068_loop
rx1066_cur."!mark_push"(0, rx1066_pos, $I10)
rxscan1068_done:
.annotate 'line', 41
# rx subrule "stopper" subtype=zerowidth negate=1
rx1066_cur."!cursor_pos"(rx1066_pos)
$P10 = rx1066_cur."stopper"()
if $P10, rx1066_fail
alt1069_0:
.annotate 'line', 42
set_addr $I10, alt1069_1
rx1066_cur."!mark_push"(0, rx1066_pos, $I10)
.annotate 'line', 43
# rx subrule "quote_escape" subtype=capture negate=
rx1066_cur."!cursor_pos"(rx1066_pos)
$P10 = rx1066_cur."quote_escape"()
unless $P10, rx1066_fail
rx1066_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("quote_escape")
rx1066_pos = $P10."pos"()
goto alt1069_end
alt1069_1:
.annotate 'line', 44
# rx rxquantr1070 ** 1..*
set_addr $I10, rxquantr1070_done
rx1066_cur."!mark_push"(0, -1, $I10)
rxquantr1070_loop:
# rx subrule "stopper" subtype=zerowidth negate=1
rx1066_cur."!cursor_pos"(rx1066_pos)
$P10 = rx1066_cur."stopper"()
if $P10, rx1066_fail
# rx subrule "quote_escape" subtype=zerowidth negate=1
rx1066_cur."!cursor_pos"(rx1066_pos)
$P10 = rx1066_cur."quote_escape"()
if $P10, rx1066_fail
# rx charclass .
ge rx1066_pos, rx1066_eos, rx1066_fail
inc rx1066_pos
set_addr $I10, rxquantr1070_done
(rx1066_rep) = rx1066_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1070_done
rx1066_cur."!mark_push"(rx1066_rep, rx1066_pos, $I10)
goto rxquantr1070_loop
rxquantr1070_done:
alt1069_end:
.annotate 'line', 40
# rx pass
rx1066_cur."!cursor_pass"(rx1066_pos, "quote_atom")
if_null rx1066_debug, debug_146
rx1066_cur."!cursor_debug"("PASS", "quote_atom", " at pos=", rx1066_pos)
debug_146:
.return (rx1066_cur)
rx1066_restart:
.annotate 'line', 5
if_null rx1066_debug, debug_147
rx1066_cur."!cursor_debug"("NEXT", "quote_atom")
debug_147:
rx1066_fail:
(rx1066_rep, rx1066_pos, $I10, $P10) = rx1066_cur."!mark_fail"(0)
lt rx1066_pos, -1, rx1066_done
eq rx1066_pos, -1, rx1066_fail
jump $I10
rx1066_done:
rx1066_cur."!cursor_fail"()
if_null rx1066_debug, debug_148
rx1066_cur."!cursor_debug"("FAIL", "quote_atom")
debug_148:
.return (rx1066_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__quote_atom" :subid("44_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "decint" :subid("45_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1072_tgt
.local int rx1072_pos
.local int rx1072_off
.local int rx1072_eos
.local int rx1072_rep
.local pmc rx1072_cur
.local pmc rx1072_debug
(rx1072_cur, rx1072_pos, rx1072_tgt, $I10) = self."!cursor_start"()
getattribute rx1072_debug, rx1072_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1072_cur
.local pmc match
.lex "$/", match
length rx1072_eos, rx1072_tgt
gt rx1072_pos, rx1072_eos, rx1072_done
set rx1072_off, 0
lt rx1072_pos, 2, rx1072_start
sub rx1072_off, rx1072_pos, 1
substr rx1072_tgt, rx1072_tgt, rx1072_off
rx1072_start:
eq $I10, 1, rx1072_restart
if_null rx1072_debug, debug_149
rx1072_cur."!cursor_debug"("START", "decint")
debug_149:
$I10 = self.'from'()
ne $I10, -1, rxscan1074_done
goto rxscan1074_scan
rxscan1074_loop:
($P10) = rx1072_cur."from"()
inc $P10
set rx1072_pos, $P10
ge rx1072_pos, rx1072_eos, rxscan1074_done
rxscan1074_scan:
set_addr $I10, rxscan1074_loop
rx1072_cur."!mark_push"(0, rx1072_pos, $I10)
rxscan1074_done:
.annotate 'line', 48
# rx rxquantr1075 ** 1..*
set_addr $I10, rxquantr1075_done
rx1072_cur."!mark_push"(0, -1, $I10)
rxquantr1075_loop:
# rx charclass_q d r 1..-1
sub $I10, rx1072_pos, rx1072_off
find_not_cclass $I11, 8, rx1072_tgt, $I10, rx1072_eos
add $I12, $I10, 1
lt $I11, $I12, rx1072_fail
add rx1072_pos, rx1072_off, $I11
set_addr $I10, rxquantr1075_done
(rx1072_rep) = rx1072_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1075_done
rx1072_cur."!mark_push"(rx1072_rep, rx1072_pos, $I10)
# rx literal "_"
add $I11, rx1072_pos, 1
gt $I11, rx1072_eos, rx1072_fail
sub $I11, rx1072_pos, rx1072_off
ord $I11, rx1072_tgt, $I11
ne $I11, 95, rx1072_fail
add rx1072_pos, 1
goto rxquantr1075_loop
rxquantr1075_done:
# rx pass
rx1072_cur."!cursor_pass"(rx1072_pos, "decint")
if_null rx1072_debug, debug_150
rx1072_cur."!cursor_debug"("PASS", "decint", " at pos=", rx1072_pos)
debug_150:
.return (rx1072_cur)
rx1072_restart:
.annotate 'line', 5
if_null rx1072_debug, debug_151
rx1072_cur."!cursor_debug"("NEXT", "decint")
debug_151:
rx1072_fail:
(rx1072_rep, rx1072_pos, $I10, $P10) = rx1072_cur."!mark_fail"(0)
lt rx1072_pos, -1, rx1072_done
eq rx1072_pos, -1, rx1072_fail
jump $I10
rx1072_done:
rx1072_cur."!cursor_fail"()
if_null rx1072_debug, debug_152
rx1072_cur."!cursor_debug"("FAIL", "decint")
debug_152:
.return (rx1072_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__decint" :subid("46_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "decints" :subid("47_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1077_tgt
.local int rx1077_pos
.local int rx1077_off
.local int rx1077_eos
.local int rx1077_rep
.local pmc rx1077_cur
.local pmc rx1077_debug
(rx1077_cur, rx1077_pos, rx1077_tgt, $I10) = self."!cursor_start"()
rx1077_cur."!cursor_caparray"("decint")
getattribute rx1077_debug, rx1077_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1077_cur
.local pmc match
.lex "$/", match
length rx1077_eos, rx1077_tgt
gt rx1077_pos, rx1077_eos, rx1077_done
set rx1077_off, 0
lt rx1077_pos, 2, rx1077_start
sub rx1077_off, rx1077_pos, 1
substr rx1077_tgt, rx1077_tgt, rx1077_off
rx1077_start:
eq $I10, 1, rx1077_restart
if_null rx1077_debug, debug_153
rx1077_cur."!cursor_debug"("START", "decints")
debug_153:
$I10 = self.'from'()
ne $I10, -1, rxscan1079_done
goto rxscan1079_scan
rxscan1079_loop:
($P10) = rx1077_cur."from"()
inc $P10
set rx1077_pos, $P10
ge rx1077_pos, rx1077_eos, rxscan1079_done
rxscan1079_scan:
set_addr $I10, rxscan1079_loop
rx1077_cur."!mark_push"(0, rx1077_pos, $I10)
rxscan1079_done:
.annotate 'line', 49
# rx rxquantr1080 ** 1..*
set_addr $I10, rxquantr1080_done
rx1077_cur."!mark_push"(0, -1, $I10)
rxquantr1080_loop:
# rx subrule "ws" subtype=method negate=
rx1077_cur."!cursor_pos"(rx1077_pos)
$P10 = rx1077_cur."ws"()
unless $P10, rx1077_fail
rx1077_pos = $P10."pos"()
# rx subrule "decint" subtype=capture negate=
rx1077_cur."!cursor_pos"(rx1077_pos)
$P10 = rx1077_cur."decint"()
unless $P10, rx1077_fail
rx1077_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("decint")
rx1077_pos = $P10."pos"()
# rx subrule "ws" subtype=method negate=
rx1077_cur."!cursor_pos"(rx1077_pos)
$P10 = rx1077_cur."ws"()
unless $P10, rx1077_fail
rx1077_pos = $P10."pos"()
set_addr $I10, rxquantr1080_done
(rx1077_rep) = rx1077_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1080_done
rx1077_cur."!mark_push"(rx1077_rep, rx1077_pos, $I10)
# rx literal ","
add $I11, rx1077_pos, 1
gt $I11, rx1077_eos, rx1077_fail
sub $I11, rx1077_pos, rx1077_off
ord $I11, rx1077_tgt, $I11
ne $I11, 44, rx1077_fail
add rx1077_pos, 1
goto rxquantr1080_loop
rxquantr1080_done:
# rx pass
rx1077_cur."!cursor_pass"(rx1077_pos, "decints")
if_null rx1077_debug, debug_154
rx1077_cur."!cursor_debug"("PASS", "decints", " at pos=", rx1077_pos)
debug_154:
.return (rx1077_cur)
rx1077_restart:
.annotate 'line', 5
if_null rx1077_debug, debug_155
rx1077_cur."!cursor_debug"("NEXT", "decints")
debug_155:
rx1077_fail:
(rx1077_rep, rx1077_pos, $I10, $P10) = rx1077_cur."!mark_fail"(0)
lt rx1077_pos, -1, rx1077_done
eq rx1077_pos, -1, rx1077_fail
jump $I10
rx1077_done:
rx1077_cur."!cursor_fail"()
if_null rx1077_debug, debug_156
rx1077_cur."!cursor_debug"("FAIL", "decints")
debug_156:
.return (rx1077_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__decints" :subid("48_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "hexint" :subid("49_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1082_tgt
.local int rx1082_pos
.local int rx1082_off
.local int rx1082_eos
.local int rx1082_rep
.local pmc rx1082_cur
.local pmc rx1082_debug
(rx1082_cur, rx1082_pos, rx1082_tgt, $I10) = self."!cursor_start"()
getattribute rx1082_debug, rx1082_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1082_cur
.local pmc match
.lex "$/", match
length rx1082_eos, rx1082_tgt
gt rx1082_pos, rx1082_eos, rx1082_done
set rx1082_off, 0
lt rx1082_pos, 2, rx1082_start
sub rx1082_off, rx1082_pos, 1
substr rx1082_tgt, rx1082_tgt, rx1082_off
rx1082_start:
eq $I10, 1, rx1082_restart
if_null rx1082_debug, debug_157
rx1082_cur."!cursor_debug"("START", "hexint")
debug_157:
$I10 = self.'from'()
ne $I10, -1, rxscan1084_done
goto rxscan1084_scan
rxscan1084_loop:
($P10) = rx1082_cur."from"()
inc $P10
set rx1082_pos, $P10
ge rx1082_pos, rx1082_eos, rxscan1084_done
rxscan1084_scan:
set_addr $I10, rxscan1084_loop
rx1082_cur."!mark_push"(0, rx1082_pos, $I10)
rxscan1084_done:
.annotate 'line', 51
# rx rxquantr1085 ** 1..*
set_addr $I10, rxquantr1085_done
rx1082_cur."!mark_push"(0, -1, $I10)
rxquantr1085_loop:
# rx enumcharlist_q negate=0 r 1..-1
sub $I10, rx1082_pos, rx1082_off
set rx1082_rep, 0
sub $I12, rx1082_eos, rx1082_pos
rxenumcharlistq1086_loop:
le $I12, 0, rxenumcharlistq1086_done
substr $S10, rx1082_tgt, $I10, 1
index $I11, "0123456789abcdefABCDEF", $S10
lt $I11, 0, rxenumcharlistq1086_done
inc rx1082_rep
inc $I10
dec $I12
goto rxenumcharlistq1086_loop
rxenumcharlistq1086_done:
lt rx1082_rep, 1, rx1082_fail
add rx1082_pos, rx1082_pos, rx1082_rep
set_addr $I10, rxquantr1085_done
(rx1082_rep) = rx1082_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1085_done
rx1082_cur."!mark_push"(rx1082_rep, rx1082_pos, $I10)
# rx literal "_"
add $I11, rx1082_pos, 1
gt $I11, rx1082_eos, rx1082_fail
sub $I11, rx1082_pos, rx1082_off
ord $I11, rx1082_tgt, $I11
ne $I11, 95, rx1082_fail
add rx1082_pos, 1
goto rxquantr1085_loop
rxquantr1085_done:
# rx pass
rx1082_cur."!cursor_pass"(rx1082_pos, "hexint")
if_null rx1082_debug, debug_158
rx1082_cur."!cursor_debug"("PASS", "hexint", " at pos=", rx1082_pos)
debug_158:
.return (rx1082_cur)
rx1082_restart:
.annotate 'line', 5
if_null rx1082_debug, debug_159
rx1082_cur."!cursor_debug"("NEXT", "hexint")
debug_159:
rx1082_fail:
(rx1082_rep, rx1082_pos, $I10, $P10) = rx1082_cur."!mark_fail"(0)
lt rx1082_pos, -1, rx1082_done
eq rx1082_pos, -1, rx1082_fail
jump $I10
rx1082_done:
rx1082_cur."!cursor_fail"()
if_null rx1082_debug, debug_160
rx1082_cur."!cursor_debug"("FAIL", "hexint")
debug_160:
.return (rx1082_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__hexint" :subid("50_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "hexints" :subid("51_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1088_tgt
.local int rx1088_pos
.local int rx1088_off
.local int rx1088_eos
.local int rx1088_rep
.local pmc rx1088_cur
.local pmc rx1088_debug
(rx1088_cur, rx1088_pos, rx1088_tgt, $I10) = self."!cursor_start"()
rx1088_cur."!cursor_caparray"("hexint")
getattribute rx1088_debug, rx1088_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1088_cur
.local pmc match
.lex "$/", match
length rx1088_eos, rx1088_tgt
gt rx1088_pos, rx1088_eos, rx1088_done
set rx1088_off, 0
lt rx1088_pos, 2, rx1088_start
sub rx1088_off, rx1088_pos, 1
substr rx1088_tgt, rx1088_tgt, rx1088_off
rx1088_start:
eq $I10, 1, rx1088_restart
if_null rx1088_debug, debug_161
rx1088_cur."!cursor_debug"("START", "hexints")
debug_161:
$I10 = self.'from'()
ne $I10, -1, rxscan1090_done
goto rxscan1090_scan
rxscan1090_loop:
($P10) = rx1088_cur."from"()
inc $P10
set rx1088_pos, $P10
ge rx1088_pos, rx1088_eos, rxscan1090_done
rxscan1090_scan:
set_addr $I10, rxscan1090_loop
rx1088_cur."!mark_push"(0, rx1088_pos, $I10)
rxscan1090_done:
.annotate 'line', 52
# rx rxquantr1091 ** 1..*
set_addr $I10, rxquantr1091_done
rx1088_cur."!mark_push"(0, -1, $I10)
rxquantr1091_loop:
# rx subrule "ws" subtype=method negate=
rx1088_cur."!cursor_pos"(rx1088_pos)
$P10 = rx1088_cur."ws"()
unless $P10, rx1088_fail
rx1088_pos = $P10."pos"()
# rx subrule "hexint" subtype=capture negate=
rx1088_cur."!cursor_pos"(rx1088_pos)
$P10 = rx1088_cur."hexint"()
unless $P10, rx1088_fail
rx1088_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("hexint")
rx1088_pos = $P10."pos"()
# rx subrule "ws" subtype=method negate=
rx1088_cur."!cursor_pos"(rx1088_pos)
$P10 = rx1088_cur."ws"()
unless $P10, rx1088_fail
rx1088_pos = $P10."pos"()
set_addr $I10, rxquantr1091_done
(rx1088_rep) = rx1088_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1091_done
rx1088_cur."!mark_push"(rx1088_rep, rx1088_pos, $I10)
# rx literal ","
add $I11, rx1088_pos, 1
gt $I11, rx1088_eos, rx1088_fail
sub $I11, rx1088_pos, rx1088_off
ord $I11, rx1088_tgt, $I11
ne $I11, 44, rx1088_fail
add rx1088_pos, 1
goto rxquantr1091_loop
rxquantr1091_done:
# rx pass
rx1088_cur."!cursor_pass"(rx1088_pos, "hexints")
if_null rx1088_debug, debug_162
rx1088_cur."!cursor_debug"("PASS", "hexints", " at pos=", rx1088_pos)
debug_162:
.return (rx1088_cur)
rx1088_restart:
.annotate 'line', 5
if_null rx1088_debug, debug_163
rx1088_cur."!cursor_debug"("NEXT", "hexints")
debug_163:
rx1088_fail:
(rx1088_rep, rx1088_pos, $I10, $P10) = rx1088_cur."!mark_fail"(0)
lt rx1088_pos, -1, rx1088_done
eq rx1088_pos, -1, rx1088_fail
jump $I10
rx1088_done:
rx1088_cur."!cursor_fail"()
if_null rx1088_debug, debug_164
rx1088_cur."!cursor_debug"("FAIL", "hexints")
debug_164:
.return (rx1088_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__hexints" :subid("52_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "octint" :subid("53_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1093_tgt
.local int rx1093_pos
.local int rx1093_off
.local int rx1093_eos
.local int rx1093_rep
.local pmc rx1093_cur
.local pmc rx1093_debug
(rx1093_cur, rx1093_pos, rx1093_tgt, $I10) = self."!cursor_start"()
getattribute rx1093_debug, rx1093_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1093_cur
.local pmc match
.lex "$/", match
length rx1093_eos, rx1093_tgt
gt rx1093_pos, rx1093_eos, rx1093_done
set rx1093_off, 0
lt rx1093_pos, 2, rx1093_start
sub rx1093_off, rx1093_pos, 1
substr rx1093_tgt, rx1093_tgt, rx1093_off
rx1093_start:
eq $I10, 1, rx1093_restart
if_null rx1093_debug, debug_165
rx1093_cur."!cursor_debug"("START", "octint")
debug_165:
$I10 = self.'from'()
ne $I10, -1, rxscan1095_done
goto rxscan1095_scan
rxscan1095_loop:
($P10) = rx1093_cur."from"()
inc $P10
set rx1093_pos, $P10
ge rx1093_pos, rx1093_eos, rxscan1095_done
rxscan1095_scan:
set_addr $I10, rxscan1095_loop
rx1093_cur."!mark_push"(0, rx1093_pos, $I10)
rxscan1095_done:
.annotate 'line', 54
# rx rxquantr1096 ** 1..*
set_addr $I10, rxquantr1096_done
rx1093_cur."!mark_push"(0, -1, $I10)
rxquantr1096_loop:
# rx enumcharlist_q negate=0 r 1..-1
sub $I10, rx1093_pos, rx1093_off
set rx1093_rep, 0
sub $I12, rx1093_eos, rx1093_pos
rxenumcharlistq1097_loop:
le $I12, 0, rxenumcharlistq1097_done
substr $S10, rx1093_tgt, $I10, 1
index $I11, "01234567", $S10
lt $I11, 0, rxenumcharlistq1097_done
inc rx1093_rep
inc $I10
dec $I12
goto rxenumcharlistq1097_loop
rxenumcharlistq1097_done:
lt rx1093_rep, 1, rx1093_fail
add rx1093_pos, rx1093_pos, rx1093_rep
set_addr $I10, rxquantr1096_done
(rx1093_rep) = rx1093_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1096_done
rx1093_cur."!mark_push"(rx1093_rep, rx1093_pos, $I10)
# rx literal "_"
add $I11, rx1093_pos, 1
gt $I11, rx1093_eos, rx1093_fail
sub $I11, rx1093_pos, rx1093_off
ord $I11, rx1093_tgt, $I11
ne $I11, 95, rx1093_fail
add rx1093_pos, 1
goto rxquantr1096_loop
rxquantr1096_done:
# rx pass
rx1093_cur."!cursor_pass"(rx1093_pos, "octint")
if_null rx1093_debug, debug_166
rx1093_cur."!cursor_debug"("PASS", "octint", " at pos=", rx1093_pos)
debug_166:
.return (rx1093_cur)
rx1093_restart:
.annotate 'line', 5
if_null rx1093_debug, debug_167
rx1093_cur."!cursor_debug"("NEXT", "octint")
debug_167:
rx1093_fail:
(rx1093_rep, rx1093_pos, $I10, $P10) = rx1093_cur."!mark_fail"(0)
lt rx1093_pos, -1, rx1093_done
eq rx1093_pos, -1, rx1093_fail
jump $I10
rx1093_done:
rx1093_cur."!cursor_fail"()
if_null rx1093_debug, debug_168
rx1093_cur."!cursor_debug"("FAIL", "octint")
debug_168:
.return (rx1093_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__octint" :subid("54_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "octints" :subid("55_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1099_tgt
.local int rx1099_pos
.local int rx1099_off
.local int rx1099_eos
.local int rx1099_rep
.local pmc rx1099_cur
.local pmc rx1099_debug
(rx1099_cur, rx1099_pos, rx1099_tgt, $I10) = self."!cursor_start"()
rx1099_cur."!cursor_caparray"("octint")
getattribute rx1099_debug, rx1099_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1099_cur
.local pmc match
.lex "$/", match
length rx1099_eos, rx1099_tgt
gt rx1099_pos, rx1099_eos, rx1099_done
set rx1099_off, 0
lt rx1099_pos, 2, rx1099_start
sub rx1099_off, rx1099_pos, 1
substr rx1099_tgt, rx1099_tgt, rx1099_off
rx1099_start:
eq $I10, 1, rx1099_restart
if_null rx1099_debug, debug_169
rx1099_cur."!cursor_debug"("START", "octints")
debug_169:
$I10 = self.'from'()
ne $I10, -1, rxscan1101_done
goto rxscan1101_scan
rxscan1101_loop:
($P10) = rx1099_cur."from"()
inc $P10
set rx1099_pos, $P10
ge rx1099_pos, rx1099_eos, rxscan1101_done
rxscan1101_scan:
set_addr $I10, rxscan1101_loop
rx1099_cur."!mark_push"(0, rx1099_pos, $I10)
rxscan1101_done:
.annotate 'line', 55
# rx rxquantr1102 ** 1..*
set_addr $I10, rxquantr1102_done
rx1099_cur."!mark_push"(0, -1, $I10)
rxquantr1102_loop:
# rx subrule "ws" subtype=method negate=
rx1099_cur."!cursor_pos"(rx1099_pos)
$P10 = rx1099_cur."ws"()
unless $P10, rx1099_fail
rx1099_pos = $P10."pos"()
# rx subrule "octint" subtype=capture negate=
rx1099_cur."!cursor_pos"(rx1099_pos)
$P10 = rx1099_cur."octint"()
unless $P10, rx1099_fail
rx1099_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("octint")
rx1099_pos = $P10."pos"()
# rx subrule "ws" subtype=method negate=
rx1099_cur."!cursor_pos"(rx1099_pos)
$P10 = rx1099_cur."ws"()
unless $P10, rx1099_fail
rx1099_pos = $P10."pos"()
set_addr $I10, rxquantr1102_done
(rx1099_rep) = rx1099_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1102_done
rx1099_cur."!mark_push"(rx1099_rep, rx1099_pos, $I10)
# rx literal ","
add $I11, rx1099_pos, 1
gt $I11, rx1099_eos, rx1099_fail
sub $I11, rx1099_pos, rx1099_off
ord $I11, rx1099_tgt, $I11
ne $I11, 44, rx1099_fail
add rx1099_pos, 1
goto rxquantr1102_loop
rxquantr1102_done:
# rx pass
rx1099_cur."!cursor_pass"(rx1099_pos, "octints")
if_null rx1099_debug, debug_170
rx1099_cur."!cursor_debug"("PASS", "octints", " at pos=", rx1099_pos)
debug_170:
.return (rx1099_cur)
rx1099_restart:
.annotate 'line', 5
if_null rx1099_debug, debug_171
rx1099_cur."!cursor_debug"("NEXT", "octints")
debug_171:
rx1099_fail:
(rx1099_rep, rx1099_pos, $I10, $P10) = rx1099_cur."!mark_fail"(0)
lt rx1099_pos, -1, rx1099_done
eq rx1099_pos, -1, rx1099_fail
jump $I10
rx1099_done:
rx1099_cur."!cursor_fail"()
if_null rx1099_debug, debug_172
rx1099_cur."!cursor_debug"("FAIL", "octints")
debug_172:
.return (rx1099_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__octints" :subid("56_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "binint" :subid("57_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1104_tgt
.local int rx1104_pos
.local int rx1104_off
.local int rx1104_eos
.local int rx1104_rep
.local pmc rx1104_cur
.local pmc rx1104_debug
(rx1104_cur, rx1104_pos, rx1104_tgt, $I10) = self."!cursor_start"()
getattribute rx1104_debug, rx1104_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1104_cur
.local pmc match
.lex "$/", match
length rx1104_eos, rx1104_tgt
gt rx1104_pos, rx1104_eos, rx1104_done
set rx1104_off, 0
lt rx1104_pos, 2, rx1104_start
sub rx1104_off, rx1104_pos, 1
substr rx1104_tgt, rx1104_tgt, rx1104_off
rx1104_start:
eq $I10, 1, rx1104_restart
if_null rx1104_debug, debug_173
rx1104_cur."!cursor_debug"("START", "binint")
debug_173:
$I10 = self.'from'()
ne $I10, -1, rxscan1106_done
goto rxscan1106_scan
rxscan1106_loop:
($P10) = rx1104_cur."from"()
inc $P10
set rx1104_pos, $P10
ge rx1104_pos, rx1104_eos, rxscan1106_done
rxscan1106_scan:
set_addr $I10, rxscan1106_loop
rx1104_cur."!mark_push"(0, rx1104_pos, $I10)
rxscan1106_done:
.annotate 'line', 57
# rx rxquantr1107 ** 1..*
set_addr $I10, rxquantr1107_done
rx1104_cur."!mark_push"(0, -1, $I10)
rxquantr1107_loop:
# rx enumcharlist_q negate=0 r 1..-1
sub $I10, rx1104_pos, rx1104_off
set rx1104_rep, 0
sub $I12, rx1104_eos, rx1104_pos
rxenumcharlistq1108_loop:
le $I12, 0, rxenumcharlistq1108_done
substr $S10, rx1104_tgt, $I10, 1
index $I11, "01", $S10
lt $I11, 0, rxenumcharlistq1108_done
inc rx1104_rep
inc $I10
dec $I12
goto rxenumcharlistq1108_loop
rxenumcharlistq1108_done:
lt rx1104_rep, 1, rx1104_fail
add rx1104_pos, rx1104_pos, rx1104_rep
set_addr $I10, rxquantr1107_done
(rx1104_rep) = rx1104_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1107_done
rx1104_cur."!mark_push"(rx1104_rep, rx1104_pos, $I10)
# rx literal "_"
add $I11, rx1104_pos, 1
gt $I11, rx1104_eos, rx1104_fail
sub $I11, rx1104_pos, rx1104_off
ord $I11, rx1104_tgt, $I11
ne $I11, 95, rx1104_fail
add rx1104_pos, 1
goto rxquantr1107_loop
rxquantr1107_done:
# rx pass
rx1104_cur."!cursor_pass"(rx1104_pos, "binint")
if_null rx1104_debug, debug_174
rx1104_cur."!cursor_debug"("PASS", "binint", " at pos=", rx1104_pos)
debug_174:
.return (rx1104_cur)
rx1104_restart:
.annotate 'line', 5
if_null rx1104_debug, debug_175
rx1104_cur."!cursor_debug"("NEXT", "binint")
debug_175:
rx1104_fail:
(rx1104_rep, rx1104_pos, $I10, $P10) = rx1104_cur."!mark_fail"(0)
lt rx1104_pos, -1, rx1104_done
eq rx1104_pos, -1, rx1104_fail
jump $I10
rx1104_done:
rx1104_cur."!cursor_fail"()
if_null rx1104_debug, debug_176
rx1104_cur."!cursor_debug"("FAIL", "binint")
debug_176:
.return (rx1104_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__binint" :subid("58_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "binints" :subid("59_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1110_tgt
.local int rx1110_pos
.local int rx1110_off
.local int rx1110_eos
.local int rx1110_rep
.local pmc rx1110_cur
.local pmc rx1110_debug
(rx1110_cur, rx1110_pos, rx1110_tgt, $I10) = self."!cursor_start"()
rx1110_cur."!cursor_caparray"("binint")
getattribute rx1110_debug, rx1110_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1110_cur
.local pmc match
.lex "$/", match
length rx1110_eos, rx1110_tgt
gt rx1110_pos, rx1110_eos, rx1110_done
set rx1110_off, 0
lt rx1110_pos, 2, rx1110_start
sub rx1110_off, rx1110_pos, 1
substr rx1110_tgt, rx1110_tgt, rx1110_off
rx1110_start:
eq $I10, 1, rx1110_restart
if_null rx1110_debug, debug_177
rx1110_cur."!cursor_debug"("START", "binints")
debug_177:
$I10 = self.'from'()
ne $I10, -1, rxscan1112_done
goto rxscan1112_scan
rxscan1112_loop:
($P10) = rx1110_cur."from"()
inc $P10
set rx1110_pos, $P10
ge rx1110_pos, rx1110_eos, rxscan1112_done
rxscan1112_scan:
set_addr $I10, rxscan1112_loop
rx1110_cur."!mark_push"(0, rx1110_pos, $I10)
rxscan1112_done:
.annotate 'line', 58
# rx rxquantr1113 ** 1..*
set_addr $I10, rxquantr1113_done
rx1110_cur."!mark_push"(0, -1, $I10)
rxquantr1113_loop:
# rx subrule "ws" subtype=method negate=
rx1110_cur."!cursor_pos"(rx1110_pos)
$P10 = rx1110_cur."ws"()
unless $P10, rx1110_fail
rx1110_pos = $P10."pos"()
# rx subrule "binint" subtype=capture negate=
rx1110_cur."!cursor_pos"(rx1110_pos)
$P10 = rx1110_cur."binint"()
unless $P10, rx1110_fail
rx1110_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("binint")
rx1110_pos = $P10."pos"()
# rx subrule "ws" subtype=method negate=
rx1110_cur."!cursor_pos"(rx1110_pos)
$P10 = rx1110_cur."ws"()
unless $P10, rx1110_fail
rx1110_pos = $P10."pos"()
set_addr $I10, rxquantr1113_done
(rx1110_rep) = rx1110_cur."!mark_commit"($I10)
set_addr $I10, rxquantr1113_done
rx1110_cur."!mark_push"(rx1110_rep, rx1110_pos, $I10)
# rx literal ","
add $I11, rx1110_pos, 1
gt $I11, rx1110_eos, rx1110_fail
sub $I11, rx1110_pos, rx1110_off
ord $I11, rx1110_tgt, $I11
ne $I11, 44, rx1110_fail
add rx1110_pos, 1
goto rxquantr1113_loop
rxquantr1113_done:
# rx pass
rx1110_cur."!cursor_pass"(rx1110_pos, "binints")
if_null rx1110_debug, debug_178
rx1110_cur."!cursor_debug"("PASS", "binints", " at pos=", rx1110_pos)
debug_178:
.return (rx1110_cur)
rx1110_restart:
.annotate 'line', 5
if_null rx1110_debug, debug_179
rx1110_cur."!cursor_debug"("NEXT", "binints")
debug_179:
rx1110_fail:
(rx1110_rep, rx1110_pos, $I10, $P10) = rx1110_cur."!mark_fail"(0)
lt rx1110_pos, -1, rx1110_done
eq rx1110_pos, -1, rx1110_fail
jump $I10
rx1110_done:
rx1110_cur."!cursor_fail"()
if_null rx1110_debug, debug_180
rx1110_cur."!cursor_debug"("FAIL", "binints")
debug_180:
.return (rx1110_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__binints" :subid("60_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, ""
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "integer" :subid("61_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1115_tgt
.local int rx1115_pos
.local int rx1115_off
.local int rx1115_eos
.local int rx1115_rep
.local pmc rx1115_cur
.local pmc rx1115_debug
(rx1115_cur, rx1115_pos, rx1115_tgt, $I10) = self."!cursor_start"()
getattribute rx1115_debug, rx1115_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1115_cur
.local pmc match
.lex "$/", match
length rx1115_eos, rx1115_tgt
gt rx1115_pos, rx1115_eos, rx1115_done
set rx1115_off, 0
lt rx1115_pos, 2, rx1115_start
sub rx1115_off, rx1115_pos, 1
substr rx1115_tgt, rx1115_tgt, rx1115_off
rx1115_start:
eq $I10, 1, rx1115_restart
if_null rx1115_debug, debug_181
rx1115_cur."!cursor_debug"("START", "integer")
debug_181:
$I10 = self.'from'()
ne $I10, -1, rxscan1117_done
goto rxscan1117_scan
rxscan1117_loop:
($P10) = rx1115_cur."from"()
inc $P10
set rx1115_pos, $P10
ge rx1115_pos, rx1115_eos, rxscan1117_done
rxscan1117_scan:
set_addr $I10, rxscan1117_loop
rx1115_cur."!mark_push"(0, rx1115_pos, $I10)
rxscan1117_done:
alt1118_0:
.annotate 'line', 61
set_addr $I10, alt1118_1
rx1115_cur."!mark_push"(0, rx1115_pos, $I10)
.annotate 'line', 62
# rx literal "0"
add $I11, rx1115_pos, 1
gt $I11, rx1115_eos, rx1115_fail
sub $I11, rx1115_pos, rx1115_off
ord $I11, rx1115_tgt, $I11
ne $I11, 48, rx1115_fail
add rx1115_pos, 1
alt1119_0:
set_addr $I10, alt1119_1
rx1115_cur."!mark_push"(0, rx1115_pos, $I10)
# rx literal "b"
add $I11, rx1115_pos, 1
gt $I11, rx1115_eos, rx1115_fail
sub $I11, rx1115_pos, rx1115_off
ord $I11, rx1115_tgt, $I11
ne $I11, 98, rx1115_fail
add rx1115_pos, 1
# rx subrule "binint" subtype=capture negate=
rx1115_cur."!cursor_pos"(rx1115_pos)
$P10 = rx1115_cur."binint"()
unless $P10, rx1115_fail
rx1115_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("VALUE=binint")
rx1115_pos = $P10."pos"()
goto alt1119_end
alt1119_1:
set_addr $I10, alt1119_2
rx1115_cur."!mark_push"(0, rx1115_pos, $I10)
.annotate 'line', 63
# rx literal "o"
add $I11, rx1115_pos, 1
gt $I11, rx1115_eos, rx1115_fail
sub $I11, rx1115_pos, rx1115_off
ord $I11, rx1115_tgt, $I11
ne $I11, 111, rx1115_fail
add rx1115_pos, 1
# rx subrule "octint" subtype=capture negate=
rx1115_cur."!cursor_pos"(rx1115_pos)
$P10 = rx1115_cur."octint"()
unless $P10, rx1115_fail
rx1115_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("VALUE=octint")
rx1115_pos = $P10."pos"()
goto alt1119_end
alt1119_2:
set_addr $I10, alt1119_3
rx1115_cur."!mark_push"(0, rx1115_pos, $I10)
.annotate 'line', 64
# rx literal "x"
add $I11, rx1115_pos, 1
gt $I11, rx1115_eos, rx1115_fail
sub $I11, rx1115_pos, rx1115_off
ord $I11, rx1115_tgt, $I11
ne $I11, 120, rx1115_fail
add rx1115_pos, 1
# rx subrule "hexint" subtype=capture negate=
rx1115_cur."!cursor_pos"(rx1115_pos)
$P10 = rx1115_cur."hexint"()
unless $P10, rx1115_fail
rx1115_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("VALUE=hexint")
rx1115_pos = $P10."pos"()
goto alt1119_end
alt1119_3:
.annotate 'line', 65
# rx literal "d"
add $I11, rx1115_pos, 1
gt $I11, rx1115_eos, rx1115_fail
sub $I11, rx1115_pos, rx1115_off
ord $I11, rx1115_tgt, $I11
ne $I11, 100, rx1115_fail
add rx1115_pos, 1
# rx subrule "decint" subtype=capture negate=
rx1115_cur."!cursor_pos"(rx1115_pos)
$P10 = rx1115_cur."decint"()
unless $P10, rx1115_fail
rx1115_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("VALUE=decint")
rx1115_pos = $P10."pos"()
alt1119_end:
.annotate 'line', 62
goto alt1118_end
alt1118_1:
.annotate 'line', 67
# rx subrule "decint" subtype=capture negate=
rx1115_cur."!cursor_pos"(rx1115_pos)
$P10 = rx1115_cur."decint"()
unless $P10, rx1115_fail
rx1115_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("VALUE=decint")
rx1115_pos = $P10."pos"()
alt1118_end:
.annotate 'line', 60
# rx pass
rx1115_cur."!cursor_pass"(rx1115_pos, "integer")
if_null rx1115_debug, debug_182
rx1115_cur."!cursor_debug"("PASS", "integer", " at pos=", rx1115_pos)
debug_182:
.return (rx1115_cur)
rx1115_restart:
.annotate 'line', 5
if_null rx1115_debug, debug_183
rx1115_cur."!cursor_debug"("NEXT", "integer")
debug_183:
rx1115_fail:
(rx1115_rep, rx1115_pos, $I10, $P10) = rx1115_cur."!mark_fail"(0)
lt rx1115_pos, -1, rx1115_done
eq rx1115_pos, -1, rx1115_fail
jump $I10
rx1115_done:
rx1115_cur."!cursor_fail"()
if_null rx1115_debug, debug_184
rx1115_cur."!cursor_debug"("FAIL", "integer")
debug_184:
.return (rx1115_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__integer" :subid("62_1308626174.53229") :method
.annotate 'line', 5
$P100 = self."!PREFIX__!subrule"("decint", "")
$P101 = self."!PREFIX__!subrule"("decint", "0d")
$P102 = self."!PREFIX__!subrule"("hexint", "0x")
$P103 = self."!PREFIX__!subrule"("octint", "0o")
$P104 = self."!PREFIX__!subrule"("binint", "0b")
new $P105, "ResizablePMCArray"
push $P105, $P100
push $P105, $P101
push $P105, $P102
push $P105, $P103
push $P105, $P104
.return ($P105)
.end
.namespace ["HLL";"Grammar"]
.sub "dec_number" :subid("63_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1121_tgt
.local int rx1121_pos
.local int rx1121_off
.local int rx1121_eos
.local int rx1121_rep
.local pmc rx1121_cur
.local pmc rx1121_debug
(rx1121_cur, rx1121_pos, rx1121_tgt, $I10) = self."!cursor_start"()
rx1121_cur."!cursor_caparray"("escale")
getattribute rx1121_debug, rx1121_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1121_cur
.local pmc match
.lex "$/", match
length rx1121_eos, rx1121_tgt
gt rx1121_pos, rx1121_eos, rx1121_done
set rx1121_off, 0
lt rx1121_pos, 2, rx1121_start
sub rx1121_off, rx1121_pos, 1
substr rx1121_tgt, rx1121_tgt, rx1121_off
rx1121_start:
eq $I10, 1, rx1121_restart
if_null rx1121_debug, debug_185
rx1121_cur."!cursor_debug"("START", "dec_number")
debug_185:
$I10 = self.'from'()
ne $I10, -1, rxscan1123_done
goto rxscan1123_scan
rxscan1123_loop:
($P10) = rx1121_cur."from"()
inc $P10
set rx1121_pos, $P10
ge rx1121_pos, rx1121_eos, rxscan1123_done
rxscan1123_scan:
set_addr $I10, rxscan1123_loop
rx1121_cur."!mark_push"(0, rx1121_pos, $I10)
rxscan1123_done:
alt1124_0:
.annotate 'line', 71
set_addr $I10, alt1124_1
rx1121_cur."!mark_push"(0, rx1121_pos, $I10)
.annotate 'line', 72
# rx subcapture "coeff"
set_addr $I10, rxcap_1125_fail
rx1121_cur."!mark_push"(0, rx1121_pos, $I10)
# rx literal "."
add $I11, rx1121_pos, 1
gt $I11, rx1121_eos, rx1121_fail
sub $I11, rx1121_pos, rx1121_off
ord $I11, rx1121_tgt, $I11
ne $I11, 46, rx1121_fail
add rx1121_pos, 1
# rx charclass_q d r 1..-1
sub $I10, rx1121_pos, rx1121_off
find_not_cclass $I11, 8, rx1121_tgt, $I10, rx1121_eos
add $I12, $I10, 1
lt $I11, $I12, rx1121_fail
add rx1121_pos, rx1121_off, $I11
set_addr $I10, rxcap_1125_fail
($I12, $I11) = rx1121_cur."!mark_peek"($I10)
rx1121_cur."!cursor_pos"($I11)
($P10) = rx1121_cur."!cursor_start"()
$P10."!cursor_pass"(rx1121_pos, "")
rx1121_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("coeff")
goto rxcap_1125_done
rxcap_1125_fail:
goto rx1121_fail
rxcap_1125_done:
# rx rxquantr1126 ** 0..1
set_addr $I10, rxquantr1126_done
rx1121_cur."!mark_push"(0, rx1121_pos, $I10)
rxquantr1126_loop:
# rx subrule "escale" subtype=capture negate=
rx1121_cur."!cursor_pos"(rx1121_pos)
$P10 = rx1121_cur."escale"()
unless $P10, rx1121_fail
goto rxsubrule1127_pass
rxsubrule1127_back:
$P10 = $P10."!cursor_next"()
unless $P10, rx1121_fail
rxsubrule1127_pass:
set_addr $I10, rxsubrule1127_back
rx1121_cur."!mark_push"(0, rx1121_pos, $I10, $P10)
$P10."!cursor_names"("escale")
rx1121_pos = $P10."pos"()
set_addr $I10, rxquantr1126_done
(rx1121_rep) = rx1121_cur."!mark_commit"($I10)
rxquantr1126_done:
goto alt1124_end
alt1124_1:
set_addr $I10, alt1124_2
rx1121_cur."!mark_push"(0, rx1121_pos, $I10)
.annotate 'line', 73
# rx subcapture "coeff"
set_addr $I10, rxcap_1128_fail
rx1121_cur."!mark_push"(0, rx1121_pos, $I10)
# rx charclass_q d r 1..-1
sub $I10, rx1121_pos, rx1121_off
find_not_cclass $I11, 8, rx1121_tgt, $I10, rx1121_eos
add $I12, $I10, 1
lt $I11, $I12, rx1121_fail
add rx1121_pos, rx1121_off, $I11
# rx literal "."
add $I11, rx1121_pos, 1
gt $I11, rx1121_eos, rx1121_fail
sub $I11, rx1121_pos, rx1121_off
ord $I11, rx1121_tgt, $I11
ne $I11, 46, rx1121_fail
add rx1121_pos, 1
# rx charclass_q d r 1..-1
sub $I10, rx1121_pos, rx1121_off
find_not_cclass $I11, 8, rx1121_tgt, $I10, rx1121_eos
add $I12, $I10, 1
lt $I11, $I12, rx1121_fail
add rx1121_pos, rx1121_off, $I11
set_addr $I10, rxcap_1128_fail
($I12, $I11) = rx1121_cur."!mark_peek"($I10)
rx1121_cur."!cursor_pos"($I11)
($P10) = rx1121_cur."!cursor_start"()
$P10."!cursor_pass"(rx1121_pos, "")
rx1121_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("coeff")
goto rxcap_1128_done
rxcap_1128_fail:
goto rx1121_fail
rxcap_1128_done:
# rx rxquantr1129 ** 0..1
set_addr $I10, rxquantr1129_done
rx1121_cur."!mark_push"(0, rx1121_pos, $I10)
rxquantr1129_loop:
# rx subrule "escale" subtype=capture negate=
rx1121_cur."!cursor_pos"(rx1121_pos)
$P10 = rx1121_cur."escale"()
unless $P10, rx1121_fail
goto rxsubrule1130_pass
rxsubrule1130_back:
$P10 = $P10."!cursor_next"()
unless $P10, rx1121_fail
rxsubrule1130_pass:
set_addr $I10, rxsubrule1130_back
rx1121_cur."!mark_push"(0, rx1121_pos, $I10, $P10)
$P10."!cursor_names"("escale")
rx1121_pos = $P10."pos"()
set_addr $I10, rxquantr1129_done
(rx1121_rep) = rx1121_cur."!mark_commit"($I10)
rxquantr1129_done:
goto alt1124_end
alt1124_2:
.annotate 'line', 74
# rx subcapture "coeff"
set_addr $I10, rxcap_1131_fail
rx1121_cur."!mark_push"(0, rx1121_pos, $I10)
# rx charclass_q d r 1..-1
sub $I10, rx1121_pos, rx1121_off
find_not_cclass $I11, 8, rx1121_tgt, $I10, rx1121_eos
add $I12, $I10, 1
lt $I11, $I12, rx1121_fail
add rx1121_pos, rx1121_off, $I11
set_addr $I10, rxcap_1131_fail
($I12, $I11) = rx1121_cur."!mark_peek"($I10)
rx1121_cur."!cursor_pos"($I11)
($P10) = rx1121_cur."!cursor_start"()
$P10."!cursor_pass"(rx1121_pos, "")
rx1121_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("coeff")
goto rxcap_1131_done
rxcap_1131_fail:
goto rx1121_fail
rxcap_1131_done:
# rx subrule "escale" subtype=capture negate=
rx1121_cur."!cursor_pos"(rx1121_pos)
$P10 = rx1121_cur."escale"()
unless $P10, rx1121_fail
rx1121_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("escale")
rx1121_pos = $P10."pos"()
alt1124_end:
.annotate 'line', 71
# rx pass
rx1121_cur."!cursor_pass"(rx1121_pos, "dec_number")
if_null rx1121_debug, debug_186
rx1121_cur."!cursor_debug"("PASS", "dec_number", " at pos=", rx1121_pos)
debug_186:
.return (rx1121_cur)
rx1121_restart:
.annotate 'line', 5
if_null rx1121_debug, debug_187
rx1121_cur."!cursor_debug"("NEXT", "dec_number")
debug_187:
rx1121_fail:
(rx1121_rep, rx1121_pos, $I10, $P10) = rx1121_cur."!mark_fail"(0)
lt rx1121_pos, -1, rx1121_done
eq rx1121_pos, -1, rx1121_fail
jump $I10
rx1121_done:
rx1121_cur."!cursor_fail"()
if_null rx1121_debug, debug_188
rx1121_cur."!cursor_debug"("FAIL", "dec_number")
debug_188:
.return (rx1121_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__dec_number" :subid("64_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, ""
push $P100, ""
push $P100, "."
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "escale" :subid("65_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1133_tgt
.local int rx1133_pos
.local int rx1133_off
.local int rx1133_eos
.local int rx1133_rep
.local pmc rx1133_cur
.local pmc rx1133_debug
(rx1133_cur, rx1133_pos, rx1133_tgt, $I10) = self."!cursor_start"()
getattribute rx1133_debug, rx1133_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1133_cur
.local pmc match
.lex "$/", match
length rx1133_eos, rx1133_tgt
gt rx1133_pos, rx1133_eos, rx1133_done
set rx1133_off, 0
lt rx1133_pos, 2, rx1133_start
sub rx1133_off, rx1133_pos, 1
substr rx1133_tgt, rx1133_tgt, rx1133_off
rx1133_start:
eq $I10, 1, rx1133_restart
if_null rx1133_debug, debug_189
rx1133_cur."!cursor_debug"("START", "escale")
debug_189:
$I10 = self.'from'()
ne $I10, -1, rxscan1135_done
goto rxscan1135_scan
rxscan1135_loop:
($P10) = rx1133_cur."from"()
inc $P10
set rx1133_pos, $P10
ge rx1133_pos, rx1133_eos, rxscan1135_done
rxscan1135_scan:
set_addr $I10, rxscan1135_loop
rx1133_cur."!mark_push"(0, rx1133_pos, $I10)
rxscan1135_done:
.annotate 'line', 77
# rx enumcharlist negate=0
ge rx1133_pos, rx1133_eos, rx1133_fail
sub $I10, rx1133_pos, rx1133_off
substr $S10, rx1133_tgt, $I10, 1
index $I11, "Ee", $S10
lt $I11, 0, rx1133_fail
inc rx1133_pos
# rx enumcharlist_q negate=0 r 0..1
sub $I10, rx1133_pos, rx1133_off
set rx1133_rep, 0
sub $I12, rx1133_eos, rx1133_pos
le $I12, 1, rxenumcharlistq1136_loop
set $I12, 1
rxenumcharlistq1136_loop:
le $I12, 0, rxenumcharlistq1136_done
substr $S10, rx1133_tgt, $I10, 1
index $I11, "+-", $S10
lt $I11, 0, rxenumcharlistq1136_done
inc rx1133_rep
rxenumcharlistq1136_done:
add rx1133_pos, rx1133_pos, rx1133_rep
# rx charclass_q d r 1..-1
sub $I10, rx1133_pos, rx1133_off
find_not_cclass $I11, 8, rx1133_tgt, $I10, rx1133_eos
add $I12, $I10, 1
lt $I11, $I12, rx1133_fail
add rx1133_pos, rx1133_off, $I11
# rx pass
rx1133_cur."!cursor_pass"(rx1133_pos, "escale")
if_null rx1133_debug, debug_190
rx1133_cur."!cursor_debug"("PASS", "escale", " at pos=", rx1133_pos)
debug_190:
.return (rx1133_cur)
rx1133_restart:
.annotate 'line', 5
if_null rx1133_debug, debug_191
rx1133_cur."!cursor_debug"("NEXT", "escale")
debug_191:
rx1133_fail:
(rx1133_rep, rx1133_pos, $I10, $P10) = rx1133_cur."!mark_fail"(0)
lt rx1133_pos, -1, rx1133_done
eq rx1133_pos, -1, rx1133_fail
jump $I10
rx1133_done:
rx1133_cur."!cursor_fail"()
if_null rx1133_debug, debug_192
rx1133_cur."!cursor_debug"("FAIL", "escale")
debug_192:
.return (rx1133_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__escale" :subid("66_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, "e"
push $P100, "E"
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "quote_escape" :subid("67_1308626174.53229") :method
.annotate 'line', 79
$P100 = self."!protoregex"("quote_escape")
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__quote_escape" :subid("68_1308626174.53229") :method
.annotate 'line', 79
$P101 = self."!PREFIX__!protoregex"("quote_escape")
.return ($P101)
.end
.namespace ["HLL";"Grammar"]
.sub "quote_escape:sym<backslash>" :subid("69_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.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_193
rx1140_cur."!cursor_debug"("START", "quote_escape:sym<backslash>")
debug_193:
$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', 80
# rx literal "\\\\"
add $I11, rx1140_pos, 2
gt $I11, rx1140_eos, rx1140_fail
sub $I11, rx1140_pos, rx1140_off
substr $S10, rx1140_tgt, $I11, 2
ne $S10, "\\\\", rx1140_fail
add rx1140_pos, 2
# rx subrule "quotemod_check" subtype=zerowidth negate=
rx1140_cur."!cursor_pos"(rx1140_pos)
$P10 = rx1140_cur."quotemod_check"("q")
unless $P10, rx1140_fail
# rx pass
rx1140_cur."!cursor_pass"(rx1140_pos, "quote_escape:sym<backslash>")
if_null rx1140_debug, debug_194
rx1140_cur."!cursor_debug"("PASS", "quote_escape:sym<backslash>", " at pos=", rx1140_pos)
debug_194:
.return (rx1140_cur)
rx1140_restart:
.annotate 'line', 5
if_null rx1140_debug, debug_195
rx1140_cur."!cursor_debug"("NEXT", "quote_escape:sym<backslash>")
debug_195:
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_196
rx1140_cur."!cursor_debug"("FAIL", "quote_escape:sym<backslash>")
debug_196:
.return (rx1140_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__quote_escape:sym<backslash>" :subid("70_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, "\\\\"
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "quote_escape:sym<stopper>" :subid("71_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1144_tgt
.local int rx1144_pos
.local int rx1144_off
.local int rx1144_eos
.local int rx1144_rep
.local pmc rx1144_cur
.local pmc rx1144_debug
(rx1144_cur, rx1144_pos, rx1144_tgt, $I10) = self."!cursor_start"()
getattribute rx1144_debug, rx1144_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1144_cur
.local pmc match
.lex "$/", match
length rx1144_eos, rx1144_tgt
gt rx1144_pos, rx1144_eos, rx1144_done
set rx1144_off, 0
lt rx1144_pos, 2, rx1144_start
sub rx1144_off, rx1144_pos, 1
substr rx1144_tgt, rx1144_tgt, rx1144_off
rx1144_start:
eq $I10, 1, rx1144_restart
if_null rx1144_debug, debug_197
rx1144_cur."!cursor_debug"("START", "quote_escape:sym<stopper>")
debug_197:
$I10 = self.'from'()
ne $I10, -1, rxscan1146_done
goto rxscan1146_scan
rxscan1146_loop:
($P10) = rx1144_cur."from"()
inc $P10
set rx1144_pos, $P10
ge rx1144_pos, rx1144_eos, rxscan1146_done
rxscan1146_scan:
set_addr $I10, rxscan1146_loop
rx1144_cur."!mark_push"(0, rx1144_pos, $I10)
rxscan1146_done:
.annotate 'line', 81
# rx literal "\\"
add $I11, rx1144_pos, 1
gt $I11, rx1144_eos, rx1144_fail
sub $I11, rx1144_pos, rx1144_off
ord $I11, rx1144_tgt, $I11
ne $I11, 92, rx1144_fail
add rx1144_pos, 1
# rx subrule "quotemod_check" subtype=zerowidth negate=
rx1144_cur."!cursor_pos"(rx1144_pos)
$P10 = rx1144_cur."quotemod_check"("q")
unless $P10, rx1144_fail
# rx subrule "stopper" subtype=capture negate=
rx1144_cur."!cursor_pos"(rx1144_pos)
$P10 = rx1144_cur."stopper"()
unless $P10, rx1144_fail
rx1144_cur."!mark_push"(0, -1, 0, $P10)
$P10."!cursor_names"("stopper")
rx1144_pos = $P10."pos"()
# rx pass
rx1144_cur."!cursor_pass"(rx1144_pos, "quote_escape:sym<stopper>")
if_null rx1144_debug, debug_198
rx1144_cur."!cursor_debug"("PASS", "quote_escape:sym<stopper>", " at pos=", rx1144_pos)
debug_198:
.return (rx1144_cur)
rx1144_restart:
.annotate 'line', 5
if_null rx1144_debug, debug_199
rx1144_cur."!cursor_debug"("NEXT", "quote_escape:sym<stopper>")
debug_199:
rx1144_fail:
(rx1144_rep, rx1144_pos, $I10, $P10) = rx1144_cur."!mark_fail"(0)
lt rx1144_pos, -1, rx1144_done
eq rx1144_pos, -1, rx1144_fail
jump $I10
rx1144_done:
rx1144_cur."!cursor_fail"()
if_null rx1144_debug, debug_200
rx1144_cur."!cursor_debug"("FAIL", "quote_escape:sym<stopper>")
debug_200:
.return (rx1144_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__quote_escape:sym<stopper>" :subid("72_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, "\\"
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "quote_escape:sym<bs>" :subid("73_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.local string rx1148_tgt
.local int rx1148_pos
.local int rx1148_off
.local int rx1148_eos
.local int rx1148_rep
.local pmc rx1148_cur
.local pmc rx1148_debug
(rx1148_cur, rx1148_pos, rx1148_tgt, $I10) = self."!cursor_start"()
getattribute rx1148_debug, rx1148_cur, "$!debug"
.lex unicode:"$\x{a2}", rx1148_cur
.local pmc match
.lex "$/", match
length rx1148_eos, rx1148_tgt
gt rx1148_pos, rx1148_eos, rx1148_done
set rx1148_off, 0
lt rx1148_pos, 2, rx1148_start
sub rx1148_off, rx1148_pos, 1
substr rx1148_tgt, rx1148_tgt, rx1148_off
rx1148_start:
eq $I10, 1, rx1148_restart
if_null rx1148_debug, debug_201
rx1148_cur."!cursor_debug"("START", "quote_escape:sym<bs>")
debug_201:
$I10 = self.'from'()
ne $I10, -1, rxscan1150_done
goto rxscan1150_scan
rxscan1150_loop:
($P10) = rx1148_cur."from"()
inc $P10
set rx1148_pos, $P10
ge rx1148_pos, rx1148_eos, rxscan1150_done
rxscan1150_scan:
set_addr $I10, rxscan1150_loop
rx1148_cur."!mark_push"(0, rx1148_pos, $I10)
rxscan1150_done:
.annotate 'line', 83
# rx literal "\\b"
add $I11, rx1148_pos, 2
gt $I11, rx1148_eos, rx1148_fail
sub $I11, rx1148_pos, rx1148_off
substr $S10, rx1148_tgt, $I11, 2
ne $S10, "\\b", rx1148_fail
add rx1148_pos, 2
# rx subrule "quotemod_check" subtype=zerowidth negate=
rx1148_cur."!cursor_pos"(rx1148_pos)
$P10 = rx1148_cur."quotemod_check"("b")
unless $P10, rx1148_fail
# rx pass
rx1148_cur."!cursor_pass"(rx1148_pos, "quote_escape:sym<bs>")
if_null rx1148_debug, debug_202
rx1148_cur."!cursor_debug"("PASS", "quote_escape:sym<bs>", " at pos=", rx1148_pos)
debug_202:
.return (rx1148_cur)
rx1148_restart:
.annotate 'line', 5
if_null rx1148_debug, debug_203
rx1148_cur."!cursor_debug"("NEXT", "quote_escape:sym<bs>")
debug_203:
rx1148_fail:
(rx1148_rep, rx1148_pos, $I10, $P10) = rx1148_cur."!mark_fail"(0)
lt rx1148_pos, -1, rx1148_done
eq rx1148_pos, -1, rx1148_fail
jump $I10
rx1148_done:
rx1148_cur."!cursor_fail"()
if_null rx1148_debug, debug_204
rx1148_cur."!cursor_debug"("FAIL", "quote_escape:sym<bs>")
debug_204:
.return (rx1148_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__quote_escape:sym<bs>" :subid("74_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, "\\b"
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "quote_escape:sym<nl>" :subid("75_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.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_205
rx1152_cur."!cursor_debug"("START", "quote_escape:sym<nl>")
debug_205:
$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', 84
# rx literal "\\n"
add $I11, rx1152_pos, 2
gt $I11, rx1152_eos, rx1152_fail
sub $I11, rx1152_pos, rx1152_off
substr $S10, rx1152_tgt, $I11, 2
ne $S10, "\\n", rx1152_fail
add rx1152_pos, 2
# rx subrule "quotemod_check" subtype=zerowidth negate=
rx1152_cur."!cursor_pos"(rx1152_pos)
$P10 = rx1152_cur."quotemod_check"("b")
unless $P10, rx1152_fail
# rx pass
rx1152_cur."!cursor_pass"(rx1152_pos, "quote_escape:sym<nl>")
if_null rx1152_debug, debug_206
rx1152_cur."!cursor_debug"("PASS", "quote_escape:sym<nl>", " at pos=", rx1152_pos)
debug_206:
.return (rx1152_cur)
rx1152_restart:
.annotate 'line', 5
if_null rx1152_debug, debug_207
rx1152_cur."!cursor_debug"("NEXT", "quote_escape:sym<nl>")
debug_207:
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_208
rx1152_cur."!cursor_debug"("FAIL", "quote_escape:sym<nl>")
debug_208:
.return (rx1152_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__quote_escape:sym<nl>" :subid("76_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, "\\n"
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "quote_escape:sym<cr>" :subid("77_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.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_209
rx1156_cur."!cursor_debug"("START", "quote_escape:sym<cr>")
debug_209:
$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', 85
# rx literal "\\r"
add $I11, rx1156_pos, 2
gt $I11, rx1156_eos, rx1156_fail
sub $I11, rx1156_pos, rx1156_off
substr $S10, rx1156_tgt, $I11, 2
ne $S10, "\\r", rx1156_fail
add rx1156_pos, 2
# rx subrule "quotemod_check" subtype=zerowidth negate=
rx1156_cur."!cursor_pos"(rx1156_pos)
$P10 = rx1156_cur."quotemod_check"("b")
unless $P10, rx1156_fail
# rx pass
rx1156_cur."!cursor_pass"(rx1156_pos, "quote_escape:sym<cr>")
if_null rx1156_debug, debug_210
rx1156_cur."!cursor_debug"("PASS", "quote_escape:sym<cr>", " at pos=", rx1156_pos)
debug_210:
.return (rx1156_cur)
rx1156_restart:
.annotate 'line', 5
if_null rx1156_debug, debug_211
rx1156_cur."!cursor_debug"("NEXT", "quote_escape:sym<cr>")
debug_211:
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_212
rx1156_cur."!cursor_debug"("FAIL", "quote_escape:sym<cr>")
debug_212:
.return (rx1156_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__quote_escape:sym<cr>" :subid("78_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, "\\r"
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "quote_escape:sym<tab>" :subid("79_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.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_213
rx1160_cur."!cursor_debug"("START", "quote_escape:sym<tab>")
debug_213:
$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', 86
# rx literal "\\t"
add $I11, rx1160_pos, 2
gt $I11, rx1160_eos, rx1160_fail
sub $I11, rx1160_pos, rx1160_off
substr $S10, rx1160_tgt, $I11, 2
ne $S10, "\\t", rx1160_fail
add rx1160_pos, 2
# rx subrule "quotemod_check" subtype=zerowidth negate=
rx1160_cur."!cursor_pos"(rx1160_pos)
$P10 = rx1160_cur."quotemod_check"("b")
unless $P10, rx1160_fail
# rx pass
rx1160_cur."!cursor_pass"(rx1160_pos, "quote_escape:sym<tab>")
if_null rx1160_debug, debug_214
rx1160_cur."!cursor_debug"("PASS", "quote_escape:sym<tab>", " at pos=", rx1160_pos)
debug_214:
.return (rx1160_cur)
rx1160_restart:
.annotate 'line', 5
if_null rx1160_debug, debug_215
rx1160_cur."!cursor_debug"("NEXT", "quote_escape:sym<tab>")
debug_215:
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_216
rx1160_cur."!cursor_debug"("FAIL", "quote_escape:sym<tab>")
debug_216:
.return (rx1160_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__quote_escape:sym<tab>" :subid("80_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, "\\t"
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "quote_escape:sym<ff>" :subid("81_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.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_217
rx1164_cur."!cursor_debug"("START", "quote_escape:sym<ff>")
debug_217:
$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', 87
# rx literal "\\f"
add $I11, rx1164_pos, 2
gt $I11, rx1164_eos, rx1164_fail
sub $I11, rx1164_pos, rx1164_off
substr $S10, rx1164_tgt, $I11, 2
ne $S10, "\\f", rx1164_fail
add rx1164_pos, 2
# rx subrule "quotemod_check" subtype=zerowidth negate=
rx1164_cur."!cursor_pos"(rx1164_pos)
$P10 = rx1164_cur."quotemod_check"("b")
unless $P10, rx1164_fail
# rx pass
rx1164_cur."!cursor_pass"(rx1164_pos, "quote_escape:sym<ff>")
if_null rx1164_debug, debug_218
rx1164_cur."!cursor_debug"("PASS", "quote_escape:sym<ff>", " at pos=", rx1164_pos)
debug_218:
.return (rx1164_cur)
rx1164_restart:
.annotate 'line', 5
if_null rx1164_debug, debug_219
rx1164_cur."!cursor_debug"("NEXT", "quote_escape:sym<ff>")
debug_219:
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_220
rx1164_cur."!cursor_debug"("FAIL", "quote_escape:sym<ff>")
debug_220:
.return (rx1164_cur)
.return ()
.end
.namespace ["HLL";"Grammar"]
.sub "!PREFIX__quote_escape:sym<ff>" :subid("82_1308626174.53229") :method
.annotate 'line', 5
new $P100, "ResizablePMCArray"
push $P100, "\\f"
.return ($P100)
.end
.namespace ["HLL";"Grammar"]
.sub "quote_escape:sym<esc>" :subid("83_1308626174.53229") :method :outer("11_1308626174.53229")
.annotate 'line', 5
.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"