Here are the examples of the python api peglet.Parser taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
3 Examples
3
Example 1
def p(grammar, text, **kwargs):
parse = Parser(grammar, **globals())
try:
return parse(text, **kwargs)
except Unparsable, e:
return e
0
Example 2
def parse(grammar):
rules = {'-a-': a_an,
'-an-': a_an,
'-a-an-': a_an,
'-adjoining-': abut,
'-capitalize-': capitalize}
parser = Parser(r"""
grammar = _ rules
rules = rule rules |
rule = name [=] _ exp hug
exp = alts mk_choice
alts = alt [/] _ alts
| alt
alt = \[ number \] _ seq mk_weight
| seq mk_unit
seq = factor seq mk_seq
| mk_empty
factor = name ![=] mk_ref
| punct mk_punct
| \( _ exp \) _
| { _ alts } _ mk_shuffle
| word { _ alts } _ mk_fixed
| word mk_literal
punct = ([.,;?!]) _
| (--?)\s _
word = ([A-Za-z0-9']+) _
name = (-[A-Za-z0-9'-]+-) _
number = (\d+) _ int
_ = (?:\s|#.*)*
""",
hug=hug,
int=int,
mk_choice = lambda *pairs: pairs[0][0] if 1 == len(pairs) else weighted_choice(dict(pairs)),
mk_empty = lambda: empty,
mk_fixed = lambda tag, *pairs: fixed(tag)(dict(pairs)),
mk_literal = literal,
mk_punct = mk_punct,
mk_ref = lambda name: delay(lambda: rules[name]),
mk_seq = lambda p, q: sequence(p, q) if q is not empty else p,
mk_shuffle = lambda *pairs: shuffled(dict(pairs)),
mk_unit = lambda p: (p, 1),
mk_weight = lambda w, p: (p, w),
)
rules.update(parser(grammar))
return rules
0
Example 3
def make_parser(maker):
def empty(): return maker.empty
def literal(char): return maker.literal(char)
def dot(): return maker.anyone
def chain(r, s): return maker.chain(r, s)
def either(r, s): return maker.either(r, s)
def both(r, s): return maker.both(r, s)
def optional(r): return either(r, empty())
if not hasattr(maker, 'star') and not hasattr(maker, 'plus'):
def star(r): raise Exception("No star() or star() constructor supplied")
def plus(r): raise Exception("No plus() or star() constructor supplied")
else:
if hasattr(maker, 'star'):
star = maker.star
else:
def star(r): return optional(plus(r))
if hasattr(maker, 'plus'):
plus = maker.plus
else:
def plus(r): return chain(r, star(r))
if hasattr(maker, 'oneof'):
oneof = maker.oneof
else:
def oneof(chars): return reduce(either, map(literal, chars))
parser = Parser(r"""
regex = exp $
exp = term [|] exp either
| term & exp both
| term
| empty
term = factor term chain
| factor
factor = primary [*] star
| primary [+] plus
| primary [?] optional
| primary
primary = \( exp \)
| \[ charset \] join oneof
| [.] dot
| \\(.) literal
| ([^.()&*+?|[\]]) literal
charset = char charset
|
char = \\(.)
| ([^\]])
""",
join=join,
**locals())
return lambda s: parser(s)[0]