2006 Scheme and Functional Programming Papers, University of

A(r{0, 0}):
✓✏ɛ
✓✏ ✎☞
> p ✲ q
✒✑push [ ] ✒✑ ✍✌
ɛ
✓✏
> p ❅ ✓✏
push [ ]
✎☞
❅❘ q
✒✑❅ ɛ ✎☞ ✎☞ ɛ
✲ p 1 A(r) q 1 ✒ ✒✑ ✍✌
cons ✍✌ ✍✌ ✻
push [ ]
ɛ
· · · ✛
A(r{0, j}):
cons
(where j ≥ 1)
✎☞ ✎☞ ɛ
✲ p k A(r) q k ✲
✍✌ ✍✌push [ ]
ɛ
· · · ✛
cons
✎☞ ✎☞ ɛ
✲ p j A(r) q j
✍✌ ✍✌push [ ]
A(r{i, j}): (where i ≥ 1)
✓✏ɛ
✎☞ ✎☞ ɛ ✎☞ ✎☞ ɛ ✓✏ ✎☞
> p ✲ p 1 A(r) q 1 ✲ · · · ✲ p i A(r) q i ✲ q
✒✑cons
✍✌ ✍✌ cons ✍✌ ✍✌push [ ] ✒✑ ✍✌
ɛ
· · · ✛
✻
cons
✎☞ ✎☞ ɛ
✲ p k A(r) q k ✲
✍✌ ✍✌push [ ]
ɛ
· · · ✛
cons
✎☞ ✎☞ ɛ
✲ p j A(r) q j
✍✌ ✍✌push [ ]
A(r 0 . . . r n−1): (where n ≥ 2):
✓✏ɛ
✎☞ ✎☞ ɛ ✎☞ ✎☞ ɛ ✓✏ ✎☞
> p ✲ p 1 A(r
✒✑cons
✍✌ 0) q 1 ✲ · · · ✲ p n A(r
✍✌ cons ✍✌
n−1) q n ✲ q
✍✌push [ ] ✒✑ ✍✌
A(r 0 | . . . | r n−1):
(where n ≥ 2)
ɛ ✎☞ ✎☞
✲
✓✏
sel 0 ✍✌
p 1 A(r 0) ✍✌
q ɛ
1
> p
❅ ✓✏
✎☞
.
❅❘ q
✒✑❅ ɛ ✎☞ ✎☞ɛ
❅ ✲ p n A(r
sel n − 1 ✍✌
n−1) q n ✒ ✒✑ ✍✌
✍✌
Figure 5. Construction rules for the automata with commands (Part II).
non-deterministic states, each on behalf of its corresponding rule.
In such a case, the deterministic state accepts on behalf of the
rule that has highest priority. The non-deterministic path P N that
corresponds to P D is recovered backwards portion by portion. The
idea consists in determining non-deterministic states {q i} 0≤i≤n
and portions of path {P i} 0≤i≤n such that: each q i is in s i; each P i
starts at q i−1, ends at q i, and consumes c i−1, except for P 0, which
starts at the non-deterministic start state, ends at q 0, and consumes
ɛ; q n is a state that accepts on behalf of the same rule as s n.
The recovery is initialized by determining q n directly from s n
using the query Acc(s n). Next, the main part of the recovery consists
in an iteration, with i going from n down to 1. At step i,
given q i, one can determine portion of path P i and intermediate
non-deterministic state q i−1. P i is obtained from the query
f(s i−1, c i−1, q i). By doing so, q i−1 is also obtained as it is the
source state of P i. As the final part of the recovery, P 0 is obtained
using the query g(q 0). Then path P N is simply the linkage of all
the portions together; i.e. P N = P 0 · . . . · P n.
Note that the preceding explanation contains some minor inaccuracies.
First, tables f and g do not exactly contain portions of
path but reversed ones. Indeed, recall that the NFA presented in
this paper are such that commands must be executed in the order
in which they are met when following paths backwards. Second,
there is no need to recover path P N (or its reverse) explicitly. It
is sufficient to keep references to the portions that form P N and
to later execute the commands by following the portions one after
the other. Better yet, one may eagerly execute the commands
contained in each portion as the latter gets determined. This way,
it is unnecessary to remember P N nor its portions. Only the current
state of the construction stack needs to be preserved. Last, one
may observe that the sole purpose of the portions of path stored in
tables f and g is to be followed in order to recover the parse tree
Scheme and Functional Programming, 2006 57