def _expressions_from_rules(self, rule_syntax, custom_rules):
        """Return the rules for parsing the grammar definition syntax.

        Return a 2-tuple: a dict of rule names pointing to their expressions,
        and then the top-level expression for the first rule.

        """
        # Hard-code enough of the rules to parse the grammar that describes the
        # grammar description language, to bootstrap:
        comment = Regex(r'#[^\r\n]*', name='comment')
        meaninglessness = OneOf(Regex(r'\s+'), comment, name='meaninglessness')
        _ = ZeroOrMore(meaninglessness, name='_')
        equals = Sequence(Literal('='), _, name='equals')
        label = Sequence(Regex(r'[a-zA-Z_][a-zA-Z_0-9]*'), _, name='label')
        reference = Sequence(label, Not(equals), name='reference')
        quantifier = Sequence(Regex(r'[*+?]'), _, name='quantifier')
        # This pattern supports empty literals. TODO: A problem?
        spaceless_literal = Regex(r'u?r?"[^"\\]*(?:\\.[^"\\]*)*"',
                                  ignore_case=True,
                                  dot_all=True,
                                  name='spaceless_literal')
        literal = Sequence(spaceless_literal, _, name='literal')
        regex = Sequence(Literal('~'),
                         literal,
                         Regex('[ilmsuxa]*', ignore_case=True),
                         _,
                         name='regex')
        atom = OneOf(reference, literal, regex, name='atom')
        quantified = Sequence(atom, quantifier, name='quantified')

        term = OneOf(quantified, atom, name='term')
        not_term = Sequence(Literal('!'), term, _, name='not_term')
        term.members = (not_term,) + term.members

        sequence = Sequence(term, OneOrMore(term), name='sequence')
        or_term = Sequence(Literal('/'), _, term, name='or_term')
        ored = Sequence(term, OneOrMore(or_term), name='ored')
        expression = OneOf(ored, sequence, term, name='expression')
        rule = Sequence(label, equals, expression, name='rule')
        rules = Sequence(_, OneOrMore(rule), name='rules')

        # Use those hard-coded rules to parse the (more extensive) rule syntax.
        # (For example, unless I start using parentheses in the rule language
        # definition itself, I should never have to hard-code expressions for
        # those above.)

        rule_tree = rules.parse(rule_syntax)

        # Turn the parse tree into a map of expressions:
        return RuleVisitor().visit(rule_tree)
def _expressions_from_rules ( self , rule_syntax , custom_rules ) : comment = Regex ( r'#[^\r\n]*' , name = 'comment' ) meaninglessness = OneOf ( Regex ( r'\s+' ) , comment , name = 'meaninglessness' ) _ = ZeroOrMore ( meaninglessness , name = '_' ) equals = Sequence ( Literal ( '=' ) , _ , name = 'equals' ) label = Sequence ( Regex ( r'[a-zA-Z_][a-zA-Z_0-9]*' ) , _ , name = 'label' ) reference = Sequence ( label , Not ( equals ) , name = 'reference' ) quantifier = Sequence ( Regex ( r'[*+?]' ) , _ , name = 'quantifier' ) spaceless_literal = Regex ( r'u?r?"[^"\\]*(?:\\.[^"\\]*)*"' , ignore_case = True , dot_all = True , name = 'spaceless_literal' ) literal = Sequence ( spaceless_literal , _ , name = 'literal' ) regex = Sequence ( Literal ( '~' ) , literal , Regex ( '[ilmsuxa]*' , ignore_case = True ) , _ , name = 'regex' ) atom = OneOf ( reference , literal , regex , name = 'atom' ) quantified = Sequence ( atom , quantifier , name = 'quantified' ) term = OneOf ( quantified , atom , name = 'term' ) not_term = Sequence ( Literal ( '!' ) , term , _ , name = 'not_term' ) term . members = ( not_term , ) + term . members sequence = Sequence ( term , OneOrMore ( term ) , name = 'sequence' ) or_term = Sequence ( Literal ( '/' ) , _ , term , name = 'or_term' ) ored = Sequence ( term , OneOrMore ( or_term ) , name = 'ored' ) expression = OneOf ( ored , sequence , term , name = 'expression' ) rule = Sequence ( label , equals , expression , name = 'rule' ) rules = Sequence ( _ , OneOrMore ( rule ) , name = 'rules' ) rule_tree = rules . parse ( rule_syntax ) return RuleVisitor ( ) . visit ( rule_tree )
Return the rules for parsing the grammar definition syntax.

        Return a 2-tuple: a dict of rule names pointing to their expressions,
        and then the top-level expression for the first rule.