peglet.Parser

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 7

Example 1

Project: peglet Source File: examples.py
Function: p
def p(grammar, text, **kwargs):
    parse = Parser(grammar, **globals())
    try:
        return parse(text, **kwargs)
    except Unparsable, e:
        return e

Example 2

Project: peglet Source File: mutagen_grammar.py
Function: parse
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

Example 3

Project: regexercise Source File: regex_parse.py
Function: make_parser
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]