diff --git a/examples/calculator/grammar_encoded_prec_parser.py b/examples/calculator/grammar_encoded_prec_parser.py index 2f1a0fe..14e9be7 100644 --- a/examples/calculator/grammar_encoded_prec_parser.py +++ b/examples/calculator/grammar_encoded_prec_parser.py @@ -9,7 +9,7 @@ Running this module directly exposes a basic command line interface for debugging grammars. - + python -m module_name --help """ @@ -34,32 +34,34 @@ class Rule(StrEnum): """Grammar rules.""" - EOI = 'EOI' - WHITESPACE = 'WHITESPACE' - PROGRAM = 'program' - EXPR = 'expr' - ADD_SUB = 'add_sub' - ADD_OP = 'add_op' - ADD = 'add' - SUB = 'sub' - MUL_DIV = 'mul_div' - MUL_OP = 'mul_op' - MUL = 'mul' - DIV = 'div' - POW_EXPR = 'pow_expr' - POW_OP = 'pow_op' - POW = 'pow' - PREFIX = 'prefix' - NEG = 'neg' - POSTFIX = 'postfix' - FAC = 'fac' - PRIMARY = 'primary' - INT = 'int' - IDENT = 'ident' + + EOI = "EOI" + WHITESPACE = "WHITESPACE" + PROGRAM = "program" + EXPR = "expr" + ADD_SUB = "add_sub" + ADD_OP = "add_op" + ADD = "add" + SUB = "sub" + MUL_DIV = "mul_div" + MUL_OP = "mul_op" + MUL = "mul" + DIV = "div" + POW_EXPR = "pow_expr" + POW_OP = "pow_op" + POW = "pow" + PREFIX = "prefix" + NEG = "neg" + POSTFIX = "postfix" + FAC = "fac" + PRIMARY = "primary" + INT = "int" + IDENT = "ident" + def _parse_EOI() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('EOI', 0) - + rule_frame = RuleFrame("EOI", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse EOI.""" pos1 = state.pos @@ -75,18 +77,29 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_EOI = _parse_EOI() + def _parse_WHITESPACE() -> Callable[[ParserState, list[Pair]], bool]: - RE3 = re.compile('(?:\\\r\\\n|[\\\t\\\n\\\r\\ ])', re.VERSION1) - - rule_frame = RuleFrame('WHITESPACE', 2) - + RE3 = re.compile("(?:\\\r\\\n|[\\\t\\\n\\\r\\ ])", re.VERSION1) + + rule_frame = RuleFrame("WHITESPACE", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse WHITESPACE.""" state.rule_stack.push(rule_frame) @@ -104,14 +117,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'WHITESPACE' pairs.extend(children2) return matched - + return inner - + + parse_WHITESPACE = _parse_WHITESPACE() + def _parse_program() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('program', 0) - + rule_frame = RuleFrame("program", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse program.""" pos1 = state.pos @@ -153,16 +168,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag5 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag5,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag5, + ) + ) return matched - + return inner - + + parse_program = _parse_program() + def _parse_expr() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('expr', 0) - + rule_frame = RuleFrame("expr", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse expr.""" pos1 = state.pos @@ -177,16 +203,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_expr = _parse_expr() + def _parse_add_sub() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('add_sub', 0) - + rule_frame = RuleFrame("add_sub", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse add_sub.""" pos1 = state.pos @@ -277,16 +314,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag10 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag10,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag10, + ) + ) return matched - + return inner - + + parse_add_sub = _parse_add_sub() + def _parse_add_op() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('add_op', 2) - + rule_frame = RuleFrame("add_op", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse add_op.""" state.rule_stack.push(rule_frame) @@ -321,21 +369,23 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'add_op' pairs.extend(children2) return matched - + return inner - + + parse_add_op = _parse_add_op() + def _parse_add() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('add', 0) - + rule_frame = RuleFrame("add", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse add.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('+', state.pos): + if state.input.startswith("+", state.pos): state.pos += 1 matched = True else: @@ -348,23 +398,34 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_add = _parse_add() + def _parse_sub() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('sub', 0) - + rule_frame = RuleFrame("sub", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse sub.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('-', state.pos): + if state.input.startswith("-", state.pos): state.pos += 1 matched = True else: @@ -377,16 +438,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_sub = _parse_sub() + def _parse_mul_div() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('mul_div', 0) - + rule_frame = RuleFrame("mul_div", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse mul_div.""" pos1 = state.pos @@ -477,16 +549,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag10 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag10,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag10, + ) + ) return matched - + return inner - + + parse_mul_div = _parse_mul_div() + def _parse_mul_op() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('mul_op', 2) - + rule_frame = RuleFrame("mul_op", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse mul_op.""" state.rule_stack.push(rule_frame) @@ -521,21 +604,23 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'mul_op' pairs.extend(children2) return matched - + return inner - + + parse_mul_op = _parse_mul_op() + def _parse_mul() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('mul', 0) - + rule_frame = RuleFrame("mul", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse mul.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('*', state.pos): + if state.input.startswith("*", state.pos): state.pos += 1 matched = True else: @@ -548,23 +633,34 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_mul = _parse_mul() + def _parse_div() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('div', 0) - + rule_frame = RuleFrame("div", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse div.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('/', state.pos): + if state.input.startswith("/", state.pos): state.pos += 1 matched = True else: @@ -577,16 +673,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_div = _parse_div() + def _parse_pow_expr() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('pow_expr', 0) - + rule_frame = RuleFrame("pow_expr", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse pow_expr.""" pos1 = state.pos @@ -648,16 +755,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag8 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag8,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag8, + ) + ) return matched - + return inner - + + parse_pow_expr = _parse_pow_expr() + def _parse_pow_op() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('pow_op', 2) - + rule_frame = RuleFrame("pow_op", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse pow_op.""" state.rule_stack.push(rule_frame) @@ -669,21 +787,23 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'pow_op' pairs.extend(children2) return matched - + return inner - + + parse_pow_op = _parse_pow_op() + def _parse_pow() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('pow', 0) - + rule_frame = RuleFrame("pow", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse pow.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('^', state.pos): + if state.input.startswith("^", state.pos): state.pos += 1 matched = True else: @@ -696,16 +816,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_pow = _parse_pow() + def _parse_prefix() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('prefix', 0) - + rule_frame = RuleFrame("prefix", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse prefix.""" pos1 = state.pos @@ -756,23 +887,34 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag7 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag7,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag7, + ) + ) return matched - + return inner - + + parse_prefix = _parse_prefix() + def _parse_neg() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('neg', 0) - + rule_frame = RuleFrame("neg", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse neg.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('-', state.pos): + if state.input.startswith("-", state.pos): state.pos += 1 matched = True else: @@ -785,16 +927,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_neg = _parse_neg() + def _parse_postfix() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('postfix', 0) - + rule_frame = RuleFrame("postfix", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse postfix.""" pos1 = state.pos @@ -836,7 +989,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok7: matched6 = False # - if state.input.startswith('(', state.pos): + if state.input.startswith("(", state.pos): state.pos += 1 matched6 = True else: @@ -859,7 +1012,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok7: matched6 = False # - if state.input.startswith(')', state.pos): + if state.input.startswith(")", state.pos): state.pos += 1 matched6 = True else: @@ -915,23 +1068,34 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag10 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag10,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag10, + ) + ) return matched - + return inner - + + parse_postfix = _parse_postfix() + def _parse_fac() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('fac', 0) - + rule_frame = RuleFrame("fac", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse fac.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('!', state.pos): + if state.input.startswith("!", state.pos): state.pos += 1 matched = True else: @@ -944,16 +1108,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_fac = _parse_fac() + def _parse_primary() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('primary', 2) - + rule_frame = RuleFrame("primary", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse primary.""" state.rule_stack.push(rule_frame) @@ -990,7 +1165,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok5: matched4 = False # - if state.input.startswith('(', state.pos): + if state.input.startswith("(", state.pos): state.pos += 1 matched4 = True else: @@ -1013,7 +1188,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok5: matched4 = False # - if state.input.startswith(')', state.pos): + if state.input.startswith(")", state.pos): state.pos += 1 matched4 = True else: @@ -1035,17 +1210,19 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'primary' pairs.extend(children2) return matched - + return inner - + + parse_primary = _parse_primary() + def _parse_int() -> Callable[[ParserState, list[Pair]], bool]: - RE6 = re.compile('[1-9]', re.I) - RE9 = re.compile('[0-9]', re.I) - - rule_frame = RuleFrame('int', 4) - + RE6 = re.compile("[1-9]", re.I) + RE9 = re.compile("[0-9]", re.I) + + rule_frame = RuleFrame("int", 4) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse int.""" pos1 = state.pos @@ -1115,7 +1292,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched: state.checkpoint() # - if state.input.startswith('0', state.pos): + if state.input.startswith("0", state.pos): state.pos += 1 matched = True else: @@ -1137,19 +1314,30 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: tag10 = None # Atomic rule: 'int' if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, [], tag10,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + [], + tag10, + ) + ) return matched - + return inner - + + parse_int = _parse_int() + def _parse_ident() -> Callable[[ParserState, list[Pair]], bool]: - RE5 = re.compile('[A-Za-z]', re.VERSION1) - RE8 = re.compile('[A-Za-z]', re.VERSION1) - - rule_frame = RuleFrame('ident', 4) - + RE5 = re.compile("[A-Za-z]", re.VERSION1) + RE8 = re.compile("[A-Za-z]", re.VERSION1) + + rule_frame = RuleFrame("ident", 4) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse ident.""" pos1 = state.pos @@ -1209,13 +1397,24 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: tag9 = None # Atomic rule: 'ident' if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, [], tag9,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + [], + tag9, + ) + ) return matched - + return inner - + + parse_ident = _parse_ident() + def parse_trivia(state: ParserState, pairs: list[Pair]) -> bool: if state.atomic_depth > 0: return True @@ -1232,31 +1431,33 @@ def parse_trivia(state: ParserState, pairs: list[Pair]) -> bool: break return True + _RULE_MAP: dict[str, Callable[[ParserState, list[Pair]], bool]] = { - 'EOI': parse_EOI, - 'WHITESPACE': parse_WHITESPACE, - 'program': parse_program, - 'expr': parse_expr, - 'add_sub': parse_add_sub, - 'add_op': parse_add_op, - 'add': parse_add, - 'sub': parse_sub, - 'mul_div': parse_mul_div, - 'mul_op': parse_mul_op, - 'mul': parse_mul, - 'div': parse_div, - 'pow_expr': parse_pow_expr, - 'pow_op': parse_pow_op, - 'pow': parse_pow, - 'prefix': parse_prefix, - 'neg': parse_neg, - 'postfix': parse_postfix, - 'fac': parse_fac, - 'primary': parse_primary, - 'int': parse_int, - 'ident': parse_ident, + "EOI": parse_EOI, + "WHITESPACE": parse_WHITESPACE, + "program": parse_program, + "expr": parse_expr, + "add_sub": parse_add_sub, + "add_op": parse_add_op, + "add": parse_add, + "sub": parse_sub, + "mul_div": parse_mul_div, + "mul_op": parse_mul_op, + "mul": parse_mul, + "div": parse_div, + "pow_expr": parse_pow_expr, + "pow_op": parse_pow_op, + "pow": parse_pow, + "prefix": parse_prefix, + "neg": parse_neg, + "postfix": parse_postfix, + "fac": parse_fac, + "primary": parse_primary, + "int": parse_int, + "ident": parse_ident, } + def parse(start_rule: str, text: str, *, start_pos: int = 0) -> Pairs: """Parse the given `text` starting from the specified `start_rule`. @@ -1279,12 +1480,15 @@ def parse(start_rule: str, text: str, *, start_pos: int = 0) -> Pairs: return Pairs(pairs) raise PestParsingError(state) + class Parser: """A class wrapping `parse()` in `Parser.parse()`.""" + def parse(self, start_rule: str, text: str, *, start_pos: int = 0) -> Pairs: """Parse the given `text` starting from the specified `start_rule`.""" return parse(start_rule, text, start_pos=start_pos) + def main() -> None: parser = argparse.ArgumentParser( prog="parser", @@ -1327,6 +1531,8 @@ def main() -> None: parse(args.rule, text).dumps(compact=not args.verbose) ) + if __name__ == "__main__": import argparse + main() diff --git a/examples/calculator/parser.py b/examples/calculator/parser.py index 56fd84b..b93af34 100644 --- a/examples/calculator/parser.py +++ b/examples/calculator/parser.py @@ -9,7 +9,7 @@ Running this module directly exposes a basic command line interface for debugging grammars. - + python -m module_name --help """ @@ -34,28 +34,30 @@ class Rule(StrEnum): """Grammar rules.""" - EOI = 'EOI' - WHITESPACE = 'WHITESPACE' - PROGRAM = 'program' - EXPR = 'expr' - INFIX = 'infix' - ADD = 'add' - SUB = 'sub' - MUL = 'mul' - DIV = 'div' - POW = 'pow' - PREFIX = 'prefix' - NEG = 'neg' - POSTFIX = 'postfix' - FAC = 'fac' - PRIMARY = 'primary' - INT = 'int' - IDENT = 'ident' - SKIP = 'SKIP' + + EOI = "EOI" + WHITESPACE = "WHITESPACE" + PROGRAM = "program" + EXPR = "expr" + INFIX = "infix" + ADD = "add" + SUB = "sub" + MUL = "mul" + DIV = "div" + POW = "pow" + PREFIX = "prefix" + NEG = "neg" + POSTFIX = "postfix" + FAC = "fac" + PRIMARY = "primary" + INT = "int" + IDENT = "ident" + SKIP = "SKIP" + def _parse_EOI() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('EOI', 0) - + rule_frame = RuleFrame("EOI", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse EOI.""" pos1 = state.pos @@ -71,18 +73,29 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_EOI = _parse_EOI() + def _parse_WHITESPACE() -> Callable[[ParserState, list[Pair]], bool]: - RE3 = re.compile('(?:\\\r\\\n|[\\\t\\\n\\\r\\ ])', re.VERSION1) - - rule_frame = RuleFrame('WHITESPACE', 2) - + RE3 = re.compile("(?:\\\r\\\n|[\\\t\\\n\\\r\\ ])", re.VERSION1) + + rule_frame = RuleFrame("WHITESPACE", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse WHITESPACE.""" state.rule_stack.push(rule_frame) @@ -100,14 +113,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'WHITESPACE' pairs.extend(children2) return matched - + return inner - + + parse_WHITESPACE = _parse_WHITESPACE() + def _parse_program() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('program', 0) - + rule_frame = RuleFrame("program", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse program.""" pos1 = state.pos @@ -149,16 +164,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag5 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag5,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag5, + ) + ) return matched - + return inner - + + parse_program = _parse_program() + def _parse_expr() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('expr', 0) - + rule_frame = RuleFrame("expr", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse expr.""" pos1 = state.pos @@ -215,7 +241,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok9: matched8 = False # - if state.input.startswith('(', state.pos): + if state.input.startswith("(", state.pos): state.pos += 1 matched8 = True else: @@ -238,7 +264,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok9: matched8 = False # - if state.input.startswith(')', state.pos): + if state.input.startswith(")", state.pos): state.pos += 1 matched8 = True else: @@ -421,7 +447,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok21: matched20 = False # - if state.input.startswith('(', state.pos): + if state.input.startswith("(", state.pos): state.pos += 1 matched20 = True else: @@ -444,7 +470,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok21: matched20 = False # - if state.input.startswith(')', state.pos): + if state.input.startswith(")", state.pos): state.pos += 1 matched20 = True else: @@ -526,16 +552,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag24 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag24,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag24, + ) + ) return matched - + return inner - + + parse_expr = _parse_expr() + def _parse_infix() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('infix', 2) - + rule_frame = RuleFrame("infix", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse infix.""" state.rule_stack.push(rule_frame) @@ -603,21 +640,23 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'infix' pairs.extend(children2) return matched - + return inner - + + parse_infix = _parse_infix() + def _parse_add() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('add', 0) - + rule_frame = RuleFrame("add", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse add.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('+', state.pos): + if state.input.startswith("+", state.pos): state.pos += 1 matched = True else: @@ -630,23 +669,34 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_add = _parse_add() + def _parse_sub() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('sub', 0) - + rule_frame = RuleFrame("sub", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse sub.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('-', state.pos): + if state.input.startswith("-", state.pos): state.pos += 1 matched = True else: @@ -659,23 +709,34 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_sub = _parse_sub() + def _parse_mul() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('mul', 0) - + rule_frame = RuleFrame("mul", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse mul.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('*', state.pos): + if state.input.startswith("*", state.pos): state.pos += 1 matched = True else: @@ -688,23 +749,34 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_mul = _parse_mul() + def _parse_div() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('div', 0) - + rule_frame = RuleFrame("div", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse div.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('/', state.pos): + if state.input.startswith("/", state.pos): state.pos += 1 matched = True else: @@ -717,23 +789,34 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_div = _parse_div() + def _parse_pow() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('pow', 0) - + rule_frame = RuleFrame("pow", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse pow.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('^', state.pos): + if state.input.startswith("^", state.pos): state.pos += 1 matched = True else: @@ -746,16 +829,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_pow = _parse_pow() + def _parse_prefix() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('prefix', 2) - + rule_frame = RuleFrame("prefix", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse prefix.""" state.rule_stack.push(rule_frame) @@ -767,21 +861,23 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'prefix' pairs.extend(children2) return matched - + return inner - + + parse_prefix = _parse_prefix() + def _parse_neg() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('neg', 0) - + rule_frame = RuleFrame("neg", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse neg.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('-', state.pos): + if state.input.startswith("-", state.pos): state.pos += 1 matched = True else: @@ -794,16 +890,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_neg = _parse_neg() + def _parse_postfix() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('postfix', 2) - + rule_frame = RuleFrame("postfix", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse postfix.""" state.rule_stack.push(rule_frame) @@ -815,21 +922,23 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'postfix' pairs.extend(children2) return matched - + return inner - + + parse_postfix = _parse_postfix() + def _parse_fac() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('fac', 0) - + rule_frame = RuleFrame("fac", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse fac.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('!', state.pos): + if state.input.startswith("!", state.pos): state.pos += 1 matched = True else: @@ -842,16 +951,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_fac = _parse_fac() + def _parse_primary() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('primary', 2) - + rule_frame = RuleFrame("primary", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse primary.""" state.rule_stack.push(rule_frame) @@ -877,7 +997,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok5: matched4 = False # - if state.input.startswith('(', state.pos): + if state.input.startswith("(", state.pos): state.pos += 1 matched4 = True else: @@ -900,7 +1020,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok5: matched4 = False # - if state.input.startswith(')', state.pos): + if state.input.startswith(")", state.pos): state.pos += 1 matched4 = True else: @@ -933,19 +1053,21 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'primary' pairs.extend(children2) return matched - + return inner - + + parse_primary = _parse_primary() + def _parse_int() -> Callable[[ParserState, list[Pair]], bool]: - RE6 = re.compile('[1-9]', re.I) - RE9 = re.compile('[0-9]', re.I) - RE12 = re.compile('[0-9]', re.I) - RE13 = re.compile('[0-9]', re.I) - - rule_frame = RuleFrame('int', 4) - + RE6 = re.compile("[1-9]", re.I) + RE9 = re.compile("[0-9]", re.I) + RE12 = re.compile("[0-9]", re.I) + RE13 = re.compile("[0-9]", re.I) + + rule_frame = RuleFrame("int", 4) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse int.""" pos1 = state.pos @@ -1059,19 +1181,30 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: tag14 = None # Atomic rule: 'int' if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, [], tag14,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + [], + tag14, + ) + ) return matched - + return inner - + + parse_int = _parse_int() + def _parse_ident() -> Callable[[ParserState, list[Pair]], bool]: - RE5 = re.compile('[A-Za-z]', re.VERSION1) - RE8 = re.compile('[A-Za-z]', re.VERSION1) - - rule_frame = RuleFrame('ident', 4) - + RE5 = re.compile("[A-Za-z]", re.VERSION1) + RE8 = re.compile("[A-Za-z]", re.VERSION1) + + rule_frame = RuleFrame("ident", 4) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse ident.""" pos1 = state.pos @@ -1131,18 +1264,29 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: tag9 = None # Atomic rule: 'ident' if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, [], tag9,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + [], + tag9, + ) + ) return matched - + return inner - + + parse_ident = _parse_ident() + def _parse_SKIP() -> Callable[[ParserState, list[Pair]], bool]: - RE3 = re.compile('(?:\\\r\\\n|[\\\t\\\n\\\r\\ ])*', re.VERSION1) - - rule_frame = RuleFrame('SKIP', 6) - + RE3 = re.compile("(?:\\\r\\\n|[\\\t\\\n\\\r\\ ])*", re.VERSION1) + + rule_frame = RuleFrame("SKIP", 6) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse SKIP.""" state.rule_stack.push(rule_frame) @@ -1160,37 +1304,41 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'SKIP' pairs.extend(children2) return matched - + return inner - + + parse_SKIP = _parse_SKIP() + def parse_trivia(state: ParserState, pairs: list[Pair]) -> bool: if state.atomic_depth > 0: return True return parse_SKIP(state, pairs) + _RULE_MAP: dict[str, Callable[[ParserState, list[Pair]], bool]] = { - 'EOI': parse_EOI, - 'WHITESPACE': parse_WHITESPACE, - 'program': parse_program, - 'expr': parse_expr, - 'infix': parse_infix, - 'add': parse_add, - 'sub': parse_sub, - 'mul': parse_mul, - 'div': parse_div, - 'pow': parse_pow, - 'prefix': parse_prefix, - 'neg': parse_neg, - 'postfix': parse_postfix, - 'fac': parse_fac, - 'primary': parse_primary, - 'int': parse_int, - 'ident': parse_ident, - 'SKIP': parse_SKIP, + "EOI": parse_EOI, + "WHITESPACE": parse_WHITESPACE, + "program": parse_program, + "expr": parse_expr, + "infix": parse_infix, + "add": parse_add, + "sub": parse_sub, + "mul": parse_mul, + "div": parse_div, + "pow": parse_pow, + "prefix": parse_prefix, + "neg": parse_neg, + "postfix": parse_postfix, + "fac": parse_fac, + "primary": parse_primary, + "int": parse_int, + "ident": parse_ident, + "SKIP": parse_SKIP, } + def parse(start_rule: str, text: str, *, start_pos: int = 0) -> Pairs: """Parse the given `text` starting from the specified `start_rule`. @@ -1213,12 +1361,15 @@ def parse(start_rule: str, text: str, *, start_pos: int = 0) -> Pairs: return Pairs(pairs) raise PestParsingError(state) + class Parser: """A class wrapping `parse()` in `Parser.parse()`.""" + def parse(self, start_rule: str, text: str, *, start_pos: int = 0) -> Pairs: """Parse the given `text` starting from the specified `start_rule`.""" return parse(start_rule, text, start_pos=start_pos) + def main() -> None: parser = argparse.ArgumentParser( prog="parser", @@ -1261,6 +1412,8 @@ def main() -> None: parse(args.rule, text).dumps(compact=not args.verbose) ) + if __name__ == "__main__": import argparse + main() diff --git a/examples/jsonpath/parser.py b/examples/jsonpath/parser.py index f8bc8a5..1537fc2 100644 --- a/examples/jsonpath/parser.py +++ b/examples/jsonpath/parser.py @@ -9,7 +9,7 @@ Running this module directly exposes a basic command line interface for debugging grammars. - + python -m module_name --help """ @@ -34,78 +34,80 @@ class Rule(StrEnum): """Grammar rules.""" - EOI = 'EOI' - JSONPATH = 'jsonpath' - JSONPATH_QUERY = 'jsonpath_query' - SEGMENTS = 'segments' - B = 'B' - S = 'S' - ROOT_IDENTIFIER = 'root_identifier' - SELECTOR = 'selector' - NAME_SELECTOR = 'name_selector' - STRING_LITERAL = 'string_literal' - DOUBLE_QUOTED = 'double_quoted' - SINGLE_QUOTED = 'single_quoted' - DOUBLE_QUOTED_CHAR = 'double_quoted_char' - SINGLE_QUOTED_CHAR = 'single_quoted_char' - ESC = 'ESC' - UNESCAPED = 'unescaped' - ESCAPABLE = 'escapable' - HEXCHAR = 'hexchar' - NON_SURROGATE = 'non_surrogate' - HIGH_SURROGATE = 'high_surrogate' - LOW_SURROGATE = 'low_surrogate' - WILDCARD_SELECTOR = 'wildcard_selector' - INDEX_SELECTOR = 'index_selector' - INT = 'int' - SLICE_SELECTOR = 'slice_selector' - START = 'start' - STOP = 'stop' - STEP = 'step' - FILTER_SELECTOR = 'filter_selector' - LOGICAL_EXPR = 'logical_expr' - LOGICAL_OR_EXPR = 'logical_or_expr' - LOGICAL_AND_EXPR = 'logical_and_expr' - BASIC_EXPR = 'basic_expr' - PAREN_EXPR = 'paren_expr' - LOGICAL_NOT_OP = 'logical_not_op' - TEST_EXPR = 'test_expr' - FILTER_QUERY = 'filter_query' - ROOT_QUERY = 'root_query' - REL_QUERY = 'rel_query' - CURRENT_NODE_IDENTIFIER = 'current_node_identifier' - COMPARISON_EXPR = 'comparison_expr' - LITERAL = 'literal' - COMPARABLE = 'comparable' - COMPARISON_OP = 'comparison_op' - SINGULAR_QUERY = 'singular_query' - REL_SINGULAR_QUERY = 'rel_singular_query' - ABS_SINGULAR_QUERY = 'abs_singular_query' - SINGULAR_QUERY_SEGMENTS = 'singular_query_segments' - NAME_SEGMENT = 'name_segment' - INDEX_SEGMENT = 'index_segment' - NUMBER = 'number' - FRAC = 'frac' - EXP = 'exp' - TRUE_LITERAL = 'true_literal' - FALSE_LITERAL = 'false_literal' - NULL = 'null' - FUNCTION_NAME = 'function_name' - FUNCTION_NAME_FIRST = 'function_name_first' - FUNCTION_NAME_CHAR = 'function_name_char' - FUNCTION_EXPR = 'function_expr' - FUNCTION_ARGUMENT = 'function_argument' - SEGMENT = 'segment' - CHILD_SEGMENT = 'child_segment' - BRACKETED_SELECTION = 'bracketed_selection' - MEMBER_NAME_SHORTHAND = 'member_name_shorthand' - NAME_FIRST = 'name_first' - NAME_CHAR = 'name_char' - DESCENDANT_SEGMENT = 'descendant_segment' + + EOI = "EOI" + JSONPATH = "jsonpath" + JSONPATH_QUERY = "jsonpath_query" + SEGMENTS = "segments" + B = "B" + S = "S" + ROOT_IDENTIFIER = "root_identifier" + SELECTOR = "selector" + NAME_SELECTOR = "name_selector" + STRING_LITERAL = "string_literal" + DOUBLE_QUOTED = "double_quoted" + SINGLE_QUOTED = "single_quoted" + DOUBLE_QUOTED_CHAR = "double_quoted_char" + SINGLE_QUOTED_CHAR = "single_quoted_char" + ESC = "ESC" + UNESCAPED = "unescaped" + ESCAPABLE = "escapable" + HEXCHAR = "hexchar" + NON_SURROGATE = "non_surrogate" + HIGH_SURROGATE = "high_surrogate" + LOW_SURROGATE = "low_surrogate" + WILDCARD_SELECTOR = "wildcard_selector" + INDEX_SELECTOR = "index_selector" + INT = "int" + SLICE_SELECTOR = "slice_selector" + START = "start" + STOP = "stop" + STEP = "step" + FILTER_SELECTOR = "filter_selector" + LOGICAL_EXPR = "logical_expr" + LOGICAL_OR_EXPR = "logical_or_expr" + LOGICAL_AND_EXPR = "logical_and_expr" + BASIC_EXPR = "basic_expr" + PAREN_EXPR = "paren_expr" + LOGICAL_NOT_OP = "logical_not_op" + TEST_EXPR = "test_expr" + FILTER_QUERY = "filter_query" + ROOT_QUERY = "root_query" + REL_QUERY = "rel_query" + CURRENT_NODE_IDENTIFIER = "current_node_identifier" + COMPARISON_EXPR = "comparison_expr" + LITERAL = "literal" + COMPARABLE = "comparable" + COMPARISON_OP = "comparison_op" + SINGULAR_QUERY = "singular_query" + REL_SINGULAR_QUERY = "rel_singular_query" + ABS_SINGULAR_QUERY = "abs_singular_query" + SINGULAR_QUERY_SEGMENTS = "singular_query_segments" + NAME_SEGMENT = "name_segment" + INDEX_SEGMENT = "index_segment" + NUMBER = "number" + FRAC = "frac" + EXP = "exp" + TRUE_LITERAL = "true_literal" + FALSE_LITERAL = "false_literal" + NULL = "null" + FUNCTION_NAME = "function_name" + FUNCTION_NAME_FIRST = "function_name_first" + FUNCTION_NAME_CHAR = "function_name_char" + FUNCTION_EXPR = "function_expr" + FUNCTION_ARGUMENT = "function_argument" + SEGMENT = "segment" + CHILD_SEGMENT = "child_segment" + BRACKETED_SELECTION = "bracketed_selection" + MEMBER_NAME_SHORTHAND = "member_name_shorthand" + NAME_FIRST = "name_first" + NAME_CHAR = "name_char" + DESCENDANT_SEGMENT = "descendant_segment" + def _parse_EOI() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('EOI', 0) - + rule_frame = RuleFrame("EOI", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse EOI.""" pos1 = state.pos @@ -121,16 +123,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_EOI = _parse_EOI() + def _parse_jsonpath() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('jsonpath', 2) - + rule_frame = RuleFrame("jsonpath", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse jsonpath.""" state.rule_stack.push(rule_frame) @@ -186,14 +199,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'jsonpath' pairs.extend(children2) return matched - + return inner - + + parse_jsonpath = _parse_jsonpath() + def _parse_jsonpath_query() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('jsonpath_query', 2) - + rule_frame = RuleFrame("jsonpath_query", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse jsonpath_query.""" state.rule_stack.push(rule_frame) @@ -203,7 +218,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith('$', state.pos): + if state.input.startswith("$", state.pos): state.pos += 1 matched3 = True else: @@ -263,14 +278,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'jsonpath_query' pairs.extend(children2) return matched - + return inner - + + parse_jsonpath_query = _parse_jsonpath_query() + def _parse_segments() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('segments', 2) - + rule_frame = RuleFrame("segments", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse segments.""" state.rule_stack.push(rule_frame) @@ -358,16 +375,18 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'segments' pairs.extend(children2) return matched - + return inner - + + parse_segments = _parse_segments() + def _parse_B() -> Callable[[ParserState, list[Pair]], bool]: - RE3 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - - rule_frame = RuleFrame('B', 2) - + RE3 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + + rule_frame = RuleFrame("B", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse B.""" state.rule_stack.push(rule_frame) @@ -383,16 +402,18 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'B' pairs.extend(children2) return matched - + return inner - + + parse_B = _parse_B() + def _parse_S() -> Callable[[ParserState, list[Pair]], bool]: - RE5 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - - rule_frame = RuleFrame('S', 2) - + RE5 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + + rule_frame = RuleFrame("S", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse S.""" state.rule_stack.push(rule_frame) @@ -425,20 +446,22 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'S' pairs.extend(children2) return matched - + return inner - + + parse_S = _parse_S() + def _parse_root_identifier() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('root_identifier', 2) - + rule_frame = RuleFrame("root_identifier", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse root_identifier.""" state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('$', state.pos): + if state.input.startswith("$", state.pos): state.pos += 1 matched = True else: @@ -449,14 +472,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'root_identifier' pairs.extend(children2) return matched - + return inner - + + parse_root_identifier = _parse_root_identifier() + def _parse_selector() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('selector', 2) - + rule_frame = RuleFrame("selector", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse selector.""" state.rule_stack.push(rule_frame) @@ -524,14 +549,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'selector' pairs.extend(children2) return matched - + return inner - + + parse_selector = _parse_selector() + def _parse_name_selector() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('name_selector', 2) - + rule_frame = RuleFrame("name_selector", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse name_selector.""" state.rule_stack.push(rule_frame) @@ -642,14 +669,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'name_selector' pairs.extend(children2) return matched - + return inner - + + parse_name_selector = _parse_name_selector() + def _parse_string_literal() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('string_literal', 2) - + rule_frame = RuleFrame("string_literal", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse string_literal.""" state.rule_stack.push(rule_frame) @@ -760,14 +789,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'string_literal' pairs.extend(children2) return matched - + return inner - + + parse_string_literal = _parse_string_literal() + def _parse_double_quoted() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('double_quoted', 0) - + rule_frame = RuleFrame("double_quoted", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse double_quoted.""" pos1 = state.pos @@ -892,16 +923,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag10 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag10,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag10, + ) + ) return matched - + return inner - + + parse_double_quoted = _parse_double_quoted() + def _parse_single_quoted() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('single_quoted', 0) - + rule_frame = RuleFrame("single_quoted", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse single_quoted.""" pos1 = state.pos @@ -1026,18 +1068,29 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag10 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag10,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag10, + ) + ) return matched - + return inner - + + parse_single_quoted = _parse_single_quoted() + def _parse_double_quoted_char() -> Callable[[ParserState, list[Pair]], bool]: - RE4 = re.compile('[\\ -!\\#-\\&\\(-\\[\\]-\ud7ff\ue000-\U0010ffff]', re.VERSION1) - - rule_frame = RuleFrame('double_quoted_char', 2) - + RE4 = re.compile("[\\ -!\\#-\\&\\(-\\[\\]-\ud7ff\ue000-\U0010ffff]", re.VERSION1) + + rule_frame = RuleFrame("double_quoted_char", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse double_quoted_char.""" state.rule_stack.push(rule_frame) @@ -1084,7 +1137,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok6: matched5 = False # - if state.input.startswith('\\', state.pos): + if state.input.startswith("\\", state.pos): state.pos += 1 matched5 = True else: @@ -1124,7 +1177,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok8: matched7 = False # - if state.input.startswith('\\', state.pos): + if state.input.startswith("\\", state.pos): state.pos += 1 matched7 = True else: @@ -1143,7 +1196,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('b', state.pos): + if state.input.startswith("b", state.pos): state.pos += 1 matched7 = True else: @@ -1159,7 +1212,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('f', state.pos): + if state.input.startswith("f", state.pos): state.pos += 1 matched7 = True else: @@ -1175,7 +1228,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('n', state.pos): + if state.input.startswith("n", state.pos): state.pos += 1 matched7 = True else: @@ -1191,7 +1244,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('r', state.pos): + if state.input.startswith("r", state.pos): state.pos += 1 matched7 = True else: @@ -1207,7 +1260,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('t', state.pos): + if state.input.startswith("t", state.pos): state.pos += 1 matched7 = True else: @@ -1223,7 +1276,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('/', state.pos): + if state.input.startswith("/", state.pos): state.pos += 1 matched7 = True else: @@ -1239,7 +1292,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('\\', state.pos): + if state.input.startswith("\\", state.pos): state.pos += 1 matched7 = True else: @@ -1260,7 +1313,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok11: matched10 = False # - if state.input.startswith('u', state.pos): + if state.input.startswith("u", state.pos): state.pos += 1 matched10 = True else: @@ -1304,16 +1357,18 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'double_quoted_char' pairs.extend(children2) return matched - + return inner - + + parse_double_quoted_char = _parse_double_quoted_char() + def _parse_single_quoted_char() -> Callable[[ParserState, list[Pair]], bool]: - RE4 = re.compile('[\\ -!\\#-\\&\\(-\\[\\]-\ud7ff\ue000-\U0010ffff]', re.VERSION1) - - rule_frame = RuleFrame('single_quoted_char', 2) - + RE4 = re.compile("[\\ -!\\#-\\&\\(-\\[\\]-\ud7ff\ue000-\U0010ffff]", re.VERSION1) + + rule_frame = RuleFrame("single_quoted_char", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse single_quoted_char.""" state.rule_stack.push(rule_frame) @@ -1360,7 +1415,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok6: matched5 = False # - if state.input.startswith('\\', state.pos): + if state.input.startswith("\\", state.pos): state.pos += 1 matched5 = True else: @@ -1400,7 +1455,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok8: matched7 = False # - if state.input.startswith('\\', state.pos): + if state.input.startswith("\\", state.pos): state.pos += 1 matched7 = True else: @@ -1419,7 +1474,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('b', state.pos): + if state.input.startswith("b", state.pos): state.pos += 1 matched7 = True else: @@ -1435,7 +1490,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('f', state.pos): + if state.input.startswith("f", state.pos): state.pos += 1 matched7 = True else: @@ -1451,7 +1506,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('n', state.pos): + if state.input.startswith("n", state.pos): state.pos += 1 matched7 = True else: @@ -1467,7 +1522,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('r', state.pos): + if state.input.startswith("r", state.pos): state.pos += 1 matched7 = True else: @@ -1483,7 +1538,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('t', state.pos): + if state.input.startswith("t", state.pos): state.pos += 1 matched7 = True else: @@ -1499,7 +1554,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('/', state.pos): + if state.input.startswith("/", state.pos): state.pos += 1 matched7 = True else: @@ -1515,7 +1570,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched7: state.checkpoint() # - if state.input.startswith('\\', state.pos): + if state.input.startswith("\\", state.pos): state.pos += 1 matched7 = True else: @@ -1536,7 +1591,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok11: matched10 = False # - if state.input.startswith('u', state.pos): + if state.input.startswith("u", state.pos): state.pos += 1 matched10 = True else: @@ -1580,20 +1635,22 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'single_quoted_char' pairs.extend(children2) return matched - + return inner - + + parse_single_quoted_char = _parse_single_quoted_char() + def _parse_ESC() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('ESC', 2) - + rule_frame = RuleFrame("ESC", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse ESC.""" state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('\\', state.pos): + if state.input.startswith("\\", state.pos): state.pos += 1 matched = True else: @@ -1604,16 +1661,18 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'ESC' pairs.extend(children2) return matched - + return inner - + + parse_ESC = _parse_ESC() + def _parse_unescaped() -> Callable[[ParserState, list[Pair]], bool]: - RE3 = re.compile('[\\ -!\\#-\\&\\(-\\[\\]-\ud7ff\ue000-\U0010ffff]', re.VERSION1) - - rule_frame = RuleFrame('unescaped', 2) - + RE3 = re.compile("[\\ -!\\#-\\&\\(-\\[\\]-\ud7ff\ue000-\U0010ffff]", re.VERSION1) + + rule_frame = RuleFrame("unescaped", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse unescaped.""" state.rule_stack.push(rule_frame) @@ -1629,14 +1688,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'unescaped' pairs.extend(children2) return matched - + return inner - + + parse_unescaped = _parse_unescaped() + def _parse_escapable() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('escapable', 2) - + rule_frame = RuleFrame("escapable", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse escapable.""" state.rule_stack.push(rule_frame) @@ -1647,7 +1708,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched: state.checkpoint() # - if state.input.startswith('b', state.pos): + if state.input.startswith("b", state.pos): state.pos += 1 matched = True else: @@ -1663,7 +1724,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched: state.checkpoint() # - if state.input.startswith('f', state.pos): + if state.input.startswith("f", state.pos): state.pos += 1 matched = True else: @@ -1679,7 +1740,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched: state.checkpoint() # - if state.input.startswith('n', state.pos): + if state.input.startswith("n", state.pos): state.pos += 1 matched = True else: @@ -1695,7 +1756,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched: state.checkpoint() # - if state.input.startswith('r', state.pos): + if state.input.startswith("r", state.pos): state.pos += 1 matched = True else: @@ -1711,7 +1772,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched: state.checkpoint() # - if state.input.startswith('t', state.pos): + if state.input.startswith("t", state.pos): state.pos += 1 matched = True else: @@ -1727,7 +1788,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched: state.checkpoint() # - if state.input.startswith('/', state.pos): + if state.input.startswith("/", state.pos): state.pos += 1 matched = True else: @@ -1743,7 +1804,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched: state.checkpoint() # - if state.input.startswith('\\', state.pos): + if state.input.startswith("\\", state.pos): state.pos += 1 matched = True else: @@ -1764,7 +1825,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok5: matched4 = False # - if state.input.startswith('u', state.pos): + if state.input.startswith("u", state.pos): state.pos += 1 matched4 = True else: @@ -1808,7 +1869,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok8: matched7 = False # - if state.input.startswith('\\u', state.pos): + if state.input.startswith("\\u", state.pos): state.pos += 2 matched7 = True else: @@ -1852,31 +1913,33 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'escapable' pairs.extend(children2) return matched - + return inner - + + parse_escapable = _parse_escapable() + def _parse_hexchar() -> Callable[[ParserState, list[Pair]], bool]: - RE7 = re.compile('[ABCEFabcef0-9]', re.VERSION1) - RE10 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE11 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE12 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE15 = re.compile('D', re.I) - RE16 = re.compile('[0-7]', re.I) - RE19 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE20 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE25 = re.compile('D', re.I) - RE26 = re.compile('[89ABab]', re.VERSION1) - RE29 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE30 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE33 = re.compile('D', re.I) - RE34 = re.compile('[CDEFcdef]', re.VERSION1) - RE37 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE38 = re.compile('[0-9A-Fa-f]', re.VERSION1) - - rule_frame = RuleFrame('hexchar', 2) - + RE7 = re.compile("[ABCEFabcef0-9]", re.VERSION1) + RE10 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE11 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE12 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE15 = re.compile("D", re.I) + RE16 = re.compile("[0-7]", re.I) + RE19 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE20 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE25 = re.compile("D", re.I) + RE26 = re.compile("[89ABab]", re.VERSION1) + RE29 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE30 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE33 = re.compile("D", re.I) + RE34 = re.compile("[CDEFcdef]", re.VERSION1) + RE37 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE38 = re.compile("[0-9A-Fa-f]", re.VERSION1) + + rule_frame = RuleFrame("hexchar", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse hexchar.""" state.rule_stack.push(rule_frame) @@ -2123,7 +2186,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok22: matched21 = False # - if state.input.startswith('\\u', state.pos): + if state.input.startswith("\\u", state.pos): state.pos += 2 matched21 = True else: @@ -2217,23 +2280,25 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'hexchar' pairs.extend(children2) return matched - + return inner - + + parse_hexchar = _parse_hexchar() + def _parse_non_surrogate() -> Callable[[ParserState, list[Pair]], bool]: - RE6 = re.compile('[ABCEFabcef0-9]', re.VERSION1) - RE9 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE10 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE11 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE14 = re.compile('D', re.I) - RE15 = re.compile('[0-7]', re.I) - RE18 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE19 = re.compile('[0-9A-Fa-f]', re.VERSION1) - - rule_frame = RuleFrame('non_surrogate', 2) - + RE6 = re.compile("[ABCEFabcef0-9]", re.VERSION1) + RE9 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE10 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE11 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE14 = re.compile("D", re.I) + RE15 = re.compile("[0-7]", re.I) + RE18 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE19 = re.compile("[0-9A-Fa-f]", re.VERSION1) + + rule_frame = RuleFrame("non_surrogate", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse non_surrogate.""" state.rule_stack.push(rule_frame) @@ -2394,19 +2459,21 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'non_surrogate' pairs.extend(children2) return matched - + return inner - + + parse_non_surrogate = _parse_non_surrogate() + def _parse_high_surrogate() -> Callable[[ParserState, list[Pair]], bool]: - RE5 = re.compile('D', re.I) - RE6 = re.compile('[89ABab]', re.VERSION1) - RE9 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE10 = re.compile('[0-9A-Fa-f]', re.VERSION1) - - rule_frame = RuleFrame('high_surrogate', 2) - + RE5 = re.compile("D", re.I) + RE6 = re.compile("[89ABab]", re.VERSION1) + RE9 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE10 = re.compile("[0-9A-Fa-f]", re.VERSION1) + + rule_frame = RuleFrame("high_surrogate", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse high_surrogate.""" state.rule_stack.push(rule_frame) @@ -2480,19 +2547,21 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'high_surrogate' pairs.extend(children2) return matched - + return inner - + + parse_high_surrogate = _parse_high_surrogate() + def _parse_low_surrogate() -> Callable[[ParserState, list[Pair]], bool]: - RE5 = re.compile('D', re.I) - RE6 = re.compile('[CDEFcdef]', re.VERSION1) - RE9 = re.compile('[0-9A-Fa-f]', re.VERSION1) - RE10 = re.compile('[0-9A-Fa-f]', re.VERSION1) - - rule_frame = RuleFrame('low_surrogate', 2) - + RE5 = re.compile("D", re.I) + RE6 = re.compile("[CDEFcdef]", re.VERSION1) + RE9 = re.compile("[0-9A-Fa-f]", re.VERSION1) + RE10 = re.compile("[0-9A-Fa-f]", re.VERSION1) + + rule_frame = RuleFrame("low_surrogate", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse low_surrogate.""" state.rule_stack.push(rule_frame) @@ -2566,21 +2635,23 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'low_surrogate' pairs.extend(children2) return matched - + return inner - + + parse_low_surrogate = _parse_low_surrogate() + def _parse_wildcard_selector() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('wildcard_selector', 0) - + rule_frame = RuleFrame("wildcard_selector", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse wildcard_selector.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('*', state.pos): + if state.input.startswith("*", state.pos): state.pos += 1 matched = True else: @@ -2593,16 +2664,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_wildcard_selector = _parse_wildcard_selector() + def _parse_index_selector() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('index_selector', 4) - + rule_frame = RuleFrame("index_selector", 4) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse index_selector.""" pos1 = state.pos @@ -2620,19 +2702,30 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: tag3 = None # Atomic rule: 'index_selector' if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, [], tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + [], + tag3, + ) + ) return matched - + return inner - + + parse_index_selector = _parse_index_selector() + def _parse_int() -> Callable[[ParserState, list[Pair]], bool]: - RE7 = re.compile('[1-9]', re.I) - RE10 = re.compile('[0-9]', re.I) - - rule_frame = RuleFrame('int', 0) - + RE7 = re.compile("[1-9]", re.I) + RE10 = re.compile("[0-9]", re.I) + + rule_frame = RuleFrame("int", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse int.""" pos1 = state.pos @@ -2644,7 +2737,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched: state.checkpoint() # - if state.input.startswith('0', state.pos): + if state.input.startswith("0", state.pos): state.pos += 1 matched = True else: @@ -2668,7 +2761,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: children6: list[Pair] = [] state.checkpoint() # - if state.input.startswith('-', state.pos): + if state.input.startswith("-", state.pos): state.pos += 1 matched4 = True else: @@ -2746,21 +2839,32 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag11 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag11,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag11, + ) + ) return matched - + return inner - + + parse_int = _parse_int() + def _parse_slice_selector() -> Callable[[ParserState, list[Pair]], bool]: - RE10 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE13 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE19 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE28 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - - rule_frame = RuleFrame('slice_selector', 0) - + RE10 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE13 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE19 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE28 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + + rule_frame = RuleFrame("slice_selector", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse slice_selector.""" pos1 = state.pos @@ -2831,7 +2935,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith(':', state.pos): + if state.input.startswith(":", state.pos): state.pos += 1 matched3 = True else: @@ -2943,7 +3047,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok22: matched21 = False # - if state.input.startswith(':', state.pos): + if state.input.startswith(":", state.pos): state.pos += 1 matched21 = True else: @@ -3033,16 +3137,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag29 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag29,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag29, + ) + ) return matched - + return inner - + + parse_slice_selector = _parse_slice_selector() + def _parse_start() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('start', 4) - + rule_frame = RuleFrame("start", 4) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse start.""" pos1 = state.pos @@ -3060,16 +3175,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: tag3 = None # Atomic rule: 'start' if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, [], tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + [], + tag3, + ) + ) return matched - + return inner - + + parse_start = _parse_start() + def _parse_stop() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('stop', 4) - + rule_frame = RuleFrame("stop", 4) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse stop.""" pos1 = state.pos @@ -3087,16 +3213,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: tag3 = None # Atomic rule: 'stop' if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, [], tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + [], + tag3, + ) + ) return matched - + return inner - + + parse_stop = _parse_stop() + def _parse_step() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('step', 4) - + rule_frame = RuleFrame("step", 4) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse step.""" pos1 = state.pos @@ -3114,18 +3251,29 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: tag3 = None # Atomic rule: 'step' if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, [], tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + [], + tag3, + ) + ) return matched - + return inner - + + parse_step = _parse_step() + def _parse_filter_selector() -> Callable[[ParserState, list[Pair]], bool]: - RE7 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - - rule_frame = RuleFrame('filter_selector', 0) - + RE7 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + + rule_frame = RuleFrame("filter_selector", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse filter_selector.""" pos1 = state.pos @@ -3136,7 +3284,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith('?', state.pos): + if state.input.startswith("?", state.pos): state.pos += 1 matched3 = True else: @@ -3192,16 +3340,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag8 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag8,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag8, + ) + ) return matched - + return inner - + + parse_filter_selector = _parse_filter_selector() + def _parse_logical_expr() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('logical_expr', 2) - + rule_frame = RuleFrame("logical_expr", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse logical_expr.""" state.rule_stack.push(rule_frame) @@ -3213,17 +3372,19 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'logical_expr' pairs.extend(children2) return matched - + return inner - + + parse_logical_expr = _parse_logical_expr() + def _parse_logical_or_expr() -> Callable[[ParserState, list[Pair]], bool]: - RE11 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE14 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - - rule_frame = RuleFrame('logical_or_expr', 0) - + RE11 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE14 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + + rule_frame = RuleFrame("logical_or_expr", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse logical_or_expr.""" pos1 = state.pos @@ -3283,7 +3444,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok8: matched7 = False # - if state.input.startswith('||', state.pos): + if state.input.startswith("||", state.pos): state.pos += 2 matched7 = True else: @@ -3356,19 +3517,30 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag15 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag15,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag15, + ) + ) return matched - + return inner - + + parse_logical_or_expr = _parse_logical_or_expr() + def _parse_logical_and_expr() -> Callable[[ParserState, list[Pair]], bool]: - RE12 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE15 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - - rule_frame = RuleFrame('logical_and_expr', 0) - + RE12 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE15 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + + rule_frame = RuleFrame("logical_and_expr", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse logical_and_expr.""" pos1 = state.pos @@ -3462,7 +3634,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok9: matched8 = False # - if state.input.startswith('&&', state.pos): + if state.input.startswith("&&", state.pos): state.pos += 2 matched8 = True else: @@ -3569,16 +3741,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag17 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag17,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag17, + ) + ) return matched - + return inner - + + parse_logical_and_expr = _parse_logical_and_expr() + def _parse_basic_expr() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('basic_expr', 2) - + rule_frame = RuleFrame("basic_expr", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse basic_expr.""" state.rule_stack.push(rule_frame) @@ -3624,18 +3807,20 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'basic_expr' pairs.extend(children2) return matched - + return inner - + + parse_basic_expr = _parse_basic_expr() + def _parse_paren_expr() -> Callable[[ParserState, list[Pair]], bool]: - RE10 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE13 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE16 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - - rule_frame = RuleFrame('paren_expr', 0) - + RE10 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE13 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE16 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + + rule_frame = RuleFrame("paren_expr", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse paren_expr.""" pos1 = state.pos @@ -3706,7 +3891,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith('(', state.pos): + if state.input.startswith("(", state.pos): state.pos += 1 matched3 = True else: @@ -3789,7 +3974,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith(')', state.pos): + if state.input.startswith(")", state.pos): state.pos += 1 matched3 = True else: @@ -3806,23 +3991,34 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag17 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag17,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag17, + ) + ) return matched - + return inner - + + parse_paren_expr = _parse_paren_expr() + def _parse_logical_not_op() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('logical_not_op', 0) - + rule_frame = RuleFrame("logical_not_op", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse logical_not_op.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('!', state.pos): + if state.input.startswith("!", state.pos): state.pos += 1 matched = True else: @@ -3835,18 +4031,29 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_logical_not_op = _parse_logical_not_op() + def _parse_test_expr() -> Callable[[ParserState, list[Pair]], bool]: - RE10 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - - rule_frame = RuleFrame('test_expr', 0) - + RE10 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + + rule_frame = RuleFrame("test_expr", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse test_expr.""" pos1 = state.pos @@ -3977,16 +4184,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag13 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag13,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag13, + ) + ) return matched - + return inner - + + parse_test_expr = _parse_test_expr() + def _parse_filter_query() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('filter_query', 2) - + rule_frame = RuleFrame("filter_query", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse filter_query.""" state.rule_stack.push(rule_frame) @@ -4021,14 +4239,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'filter_query' pairs.extend(children2) return matched - + return inner - + + parse_filter_query = _parse_filter_query() + def _parse_root_query() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('root_query', 0) - + rule_frame = RuleFrame("root_query", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse root_query.""" pos1 = state.pos @@ -4039,7 +4259,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith('$', state.pos): + if state.input.startswith("$", state.pos): state.pos += 1 matched3 = True else: @@ -4101,16 +4321,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag9 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag9,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag9, + ) + ) return matched - + return inner - + + parse_root_query = _parse_root_query() + def _parse_rel_query() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('rel_query', 0) - + rule_frame = RuleFrame("rel_query", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse rel_query.""" pos1 = state.pos @@ -4121,7 +4352,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith('@', state.pos): + if state.input.startswith("@", state.pos): state.pos += 1 matched3 = True else: @@ -4223,22 +4454,33 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag12 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag12,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag12, + ) + ) return matched - + return inner - + + parse_rel_query = _parse_rel_query() + def _parse_current_node_identifier() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('current_node_identifier', 2) - + rule_frame = RuleFrame("current_node_identifier", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse current_node_identifier.""" state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('@', state.pos): + if state.input.startswith("@", state.pos): state.pos += 1 matched = True else: @@ -4249,17 +4491,19 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'current_node_identifier' pairs.extend(children2) return matched - + return inner - + + parse_current_node_identifier = _parse_current_node_identifier() + def _parse_comparison_expr() -> Callable[[ParserState, list[Pair]], bool]: - RE8 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE11 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - - rule_frame = RuleFrame('comparison_expr', 0) - + RE8 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE11 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + + rule_frame = RuleFrame("comparison_expr", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse comparison_expr.""" pos1 = state.pos @@ -4428,16 +4672,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag13 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag13,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag13, + ) + ) return matched - + return inner - + + parse_comparison_expr = _parse_comparison_expr() + def _parse_literal() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('literal', 2) - + rule_frame = RuleFrame("literal", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse literal.""" state.rule_stack.push(rule_frame) @@ -4604,14 +4859,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'literal' pairs.extend(children2) return matched - + return inner - + + parse_literal = _parse_literal() + def _parse_comparable() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('comparable', 2) - + rule_frame = RuleFrame("comparable", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse comparable.""" state.rule_stack.push(rule_frame) @@ -4835,16 +5092,18 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'comparable' pairs.extend(children2) return matched - + return inner - + + parse_comparable = _parse_comparable() + def _parse_comparison_op() -> Callable[[ParserState, list[Pair]], bool]: - RE3 = re.compile('(?:==|!=|<=|>=|[<>])', re.VERSION1) - - rule_frame = RuleFrame('comparison_op', 0) - + RE3 = re.compile("(?:==|!=|<=|>=|[<>])", re.VERSION1) + + rule_frame = RuleFrame("comparison_op", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse comparison_op.""" pos1 = state.pos @@ -4863,16 +5122,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag4 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag4,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag4, + ) + ) return matched - + return inner - + + parse_comparison_op = _parse_comparison_op() + def _parse_singular_query() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('singular_query', 2) - + rule_frame = RuleFrame("singular_query", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse singular_query.""" state.rule_stack.push(rule_frame) @@ -4907,14 +5177,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'singular_query' pairs.extend(children2) return matched - + return inner - + + parse_singular_query = _parse_singular_query() + def _parse_rel_singular_query() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('rel_singular_query', 0) - + rule_frame = RuleFrame("rel_singular_query", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse rel_singular_query.""" pos1 = state.pos @@ -4925,7 +5197,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith('@', state.pos): + if state.input.startswith("@", state.pos): state.pos += 1 matched3 = True else: @@ -5012,16 +5284,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag10 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag10,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag10, + ) + ) return matched - + return inner - + + parse_rel_singular_query = _parse_rel_singular_query() + def _parse_abs_singular_query() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('abs_singular_query', 0) - + rule_frame = RuleFrame("abs_singular_query", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse abs_singular_query.""" pos1 = state.pos @@ -5032,7 +5315,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith('$', state.pos): + if state.input.startswith("$", state.pos): state.pos += 1 matched3 = True else: @@ -5119,18 +5402,29 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag10 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag10,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag10, + ) + ) return matched - + return inner - + + parse_abs_singular_query = _parse_abs_singular_query() + def _parse_singular_query_segments() -> Callable[[ParserState, list[Pair]], bool]: - RE9 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - - rule_frame = RuleFrame('singular_query_segments', 2) - + RE9 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + + rule_frame = RuleFrame("singular_query_segments", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse singular_query_segments.""" state.rule_stack.push(rule_frame) @@ -5224,14 +5518,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'singular_query_segments' pairs.extend(children2) return matched - + return inner - + + parse_singular_query_segments = _parse_singular_query_segments() + def _parse_name_segment() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('name_segment', 0) - + rule_frame = RuleFrame("name_segment", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse name_segment.""" pos1 = state.pos @@ -5248,7 +5544,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok5: matched4 = False # - if state.input.startswith('[', state.pos): + if state.input.startswith("[", state.pos): state.pos += 1 matched4 = True else: @@ -5370,7 +5666,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok5: matched4 = False # - if state.input.startswith(']', state.pos): + if state.input.startswith("]", state.pos): state.pos += 1 matched4 = True else: @@ -5396,7 +5692,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok12: matched11 = False # - if state.input.startswith('.', state.pos): + if state.input.startswith(".", state.pos): state.pos += 1 matched11 = True else: @@ -5430,16 +5726,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag13 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag13,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag13, + ) + ) return matched - + return inner - + + parse_name_segment = _parse_name_segment() + def _parse_index_segment() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('index_segment', 0) - + rule_frame = RuleFrame("index_segment", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse index_segment.""" pos1 = state.pos @@ -5450,7 +5757,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith('[', state.pos): + if state.input.startswith("[", state.pos): state.pos += 1 matched3 = True else: @@ -5473,7 +5780,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith(']', state.pos): + if state.input.startswith("]", state.pos): state.pos += 1 matched3 = True else: @@ -5490,16 +5797,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag5 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag5,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag5, + ) + ) return matched - + return inner - + + parse_index_segment = _parse_index_segment() + def _parse_number() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('number', 0) - + rule_frame = RuleFrame("number", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse number.""" pos1 = state.pos @@ -5527,7 +5845,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched3: state.checkpoint() # - if state.input.startswith('-0', state.pos): + if state.input.startswith("-0", state.pos): state.pos += 2 matched3 = True else: @@ -5592,19 +5910,30 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag8 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag8,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag8, + ) + ) return matched - + return inner - + + parse_number = _parse_number() + def _parse_frac() -> Callable[[ParserState, list[Pair]], bool]: - RE7 = re.compile('[0-9]', re.I) - RE10 = re.compile('[0-9]', re.I) - - rule_frame = RuleFrame('frac', 0) - + RE7 = re.compile("[0-9]", re.I) + RE10 = re.compile("[0-9]", re.I) + + rule_frame = RuleFrame("frac", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse frac.""" pos1 = state.pos @@ -5615,7 +5944,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith('.', state.pos): + if state.input.startswith(".", state.pos): state.pos += 1 matched3 = True else: @@ -5685,21 +6014,32 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag11 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag11,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag11, + ) + ) return matched - + return inner - + + parse_frac = _parse_frac() + def _parse_exp() -> Callable[[ParserState, list[Pair]], bool]: - RE5 = re.compile('e', re.I) - RE7 = re.compile('[\\+\\-]', re.VERSION1) - RE10 = re.compile('[0-9]', re.I) - RE13 = re.compile('[0-9]', re.I) - - rule_frame = RuleFrame('exp', 0) - + RE5 = re.compile("e", re.I) + RE7 = re.compile("[\\+\\-]", re.VERSION1) + RE10 = re.compile("[0-9]", re.I) + RE13 = re.compile("[0-9]", re.I) + + rule_frame = RuleFrame("exp", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse exp.""" pos1 = state.pos @@ -5806,23 +6146,34 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag14 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag14,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag14, + ) + ) return matched - + return inner - + + parse_exp = _parse_exp() + def _parse_true_literal() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('true_literal', 0) - + rule_frame = RuleFrame("true_literal", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse true_literal.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('true', state.pos): + if state.input.startswith("true", state.pos): state.pos += 4 matched = True else: @@ -5835,23 +6186,34 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_true_literal = _parse_true_literal() + def _parse_false_literal() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('false_literal', 0) - + rule_frame = RuleFrame("false_literal", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse false_literal.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('false', state.pos): + if state.input.startswith("false", state.pos): state.pos += 5 matched = True else: @@ -5864,23 +6226,34 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_false_literal = _parse_false_literal() + def _parse_null() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('null', 0) - + rule_frame = RuleFrame("null", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse null.""" pos1 = state.pos state.rule_stack.push(rule_frame) children2: list[Pair] = [] # - if state.input.startswith('null', state.pos): + if state.input.startswith("null", state.pos): state.pos += 4 matched = True else: @@ -5893,19 +6266,30 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag3 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag3,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag3, + ) + ) return matched - + return inner - + + parse_null = _parse_null() + def _parse_function_name() -> Callable[[ParserState, list[Pair]], bool]: - RE5 = re.compile('[a-z]', re.I) - RE9 = re.compile('[0-9]', re.I) - - rule_frame = RuleFrame('function_name', 0) - + RE5 = re.compile("[a-z]", re.I) + RE9 = re.compile("[0-9]", re.I) + + rule_frame = RuleFrame("function_name", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse function_name.""" pos1 = state.pos @@ -5951,7 +6335,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched3: state.checkpoint() # - if state.input.startswith('_', state.pos): + if state.input.startswith("_", state.pos): state.pos += 1 matched3 = True else: @@ -6003,18 +6387,29 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag10 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag10,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag10, + ) + ) return matched - + return inner - + + parse_function_name = _parse_function_name() + def _parse_function_name_first() -> Callable[[ParserState, list[Pair]], bool]: - RE3 = re.compile('[a-z]', re.I) - - rule_frame = RuleFrame('function_name_first', 2) - + RE3 = re.compile("[a-z]", re.I) + + rule_frame = RuleFrame("function_name_first", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse function_name_first.""" state.rule_stack.push(rule_frame) @@ -6031,17 +6426,19 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'function_name_first' pairs.extend(children2) return matched - + return inner - + + parse_function_name_first = _parse_function_name_first() + def _parse_function_name_char() -> Callable[[ParserState, list[Pair]], bool]: - RE4 = re.compile('[a-z]', re.I) - RE5 = re.compile('[0-9]', re.I) - - rule_frame = RuleFrame('function_name_char', 2) - + RE4 = re.compile("[a-z]", re.I) + RE5 = re.compile("[0-9]", re.I) + + rule_frame = RuleFrame("function_name_char", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse function_name_char.""" state.rule_stack.push(rule_frame) @@ -6068,7 +6465,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if not matched: state.checkpoint() # - if state.input.startswith('_', state.pos): + if state.input.startswith("_", state.pos): state.pos += 1 matched = True else: @@ -6102,19 +6499,21 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'function_name_char' pairs.extend(children2) return matched - + return inner - + + parse_function_name_char = _parse_function_name_char() + def _parse_function_expr() -> Callable[[ParserState, list[Pair]], bool]: - RE7 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE18 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE21 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE25 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - - rule_frame = RuleFrame('function_expr', 0) - + RE7 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE18 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE21 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE25 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + + rule_frame = RuleFrame("function_expr", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse function_expr.""" pos1 = state.pos @@ -6134,7 +6533,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith('(', state.pos): + if state.input.startswith("(", state.pos): state.pos += 1 matched3 = True else: @@ -6280,7 +6679,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok15: matched14 = False # - if state.input.startswith(',', state.pos): + if state.input.startswith(",", state.pos): state.pos += 1 matched14 = True else: @@ -6438,7 +6837,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith(')', state.pos): + if state.input.startswith(")", state.pos): state.pos += 1 matched3 = True else: @@ -6455,16 +6854,27 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag26 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag26,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag26, + ) + ) return matched - + return inner - + + parse_function_expr = _parse_function_expr() + def _parse_function_argument() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('function_argument', 2) - + rule_frame = RuleFrame("function_argument", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse function_argument.""" state.rule_stack.push(rule_frame) @@ -6699,14 +7109,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'function_argument' pairs.extend(children2) return matched - + return inner - + + parse_function_argument = _parse_function_argument() + def _parse_segment() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('segment', 2) - + rule_frame = RuleFrame("segment", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse segment.""" state.rule_stack.push(rule_frame) @@ -6741,14 +7153,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'segment' pairs.extend(children2) return matched - + return inner - + + parse_segment = _parse_segment() + def _parse_child_segment() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('child_segment', 0) - + rule_frame = RuleFrame("child_segment", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse child_segment.""" pos1 = state.pos @@ -6776,7 +7190,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok5: matched4 = False # - if state.input.startswith('.', state.pos): + if state.input.startswith(".", state.pos): state.pos += 1 matched4 = True else: @@ -6835,21 +7249,32 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag7 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag7,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag7, + ) + ) return matched - + return inner - + + parse_child_segment = _parse_child_segment() + def _parse_bracketed_selection() -> Callable[[ParserState, list[Pair]], bool]: - RE7 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE15 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE18 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - RE22 = re.compile('[\\\t\\\n\\\r\\ ]', re.VERSION1) - - rule_frame = RuleFrame('bracketed_selection', 0) - + RE7 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE15 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE18 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + RE22 = re.compile("[\\\t\\\n\\\r\\ ]", re.VERSION1) + + rule_frame = RuleFrame("bracketed_selection", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse bracketed_selection.""" pos1 = state.pos @@ -6860,7 +7285,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith('[', state.pos): + if state.input.startswith("[", state.pos): state.pos += 1 matched3 = True else: @@ -7009,7 +7434,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok12: matched11 = False # - if state.input.startswith(',', state.pos): + if state.input.startswith(",", state.pos): state.pos += 1 matched11 = True else: @@ -7165,7 +7590,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith(']', state.pos): + if state.input.startswith("]", state.pos): state.pos += 1 matched3 = True else: @@ -7182,19 +7607,30 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag23 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag23,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag23, + ) + ) return matched - + return inner - + + parse_bracketed_selection = _parse_bracketed_selection() + def _parse_member_name_shorthand() -> Callable[[ParserState, list[Pair]], bool]: - RE5 = re.compile('[_A-Za-z\x80-\ud7ff\ue000-\U0010ffff]', re.VERSION1) - RE9 = re.compile('[0-9]', re.I) - - rule_frame = RuleFrame('member_name_shorthand', 0) - + RE5 = re.compile("[_A-Za-z\x80-\ud7ff\ue000-\U0010ffff]", re.VERSION1) + RE9 = re.compile("[0-9]", re.I) + + rule_frame = RuleFrame("member_name_shorthand", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse member_name_shorthand.""" pos1 = state.pos @@ -7275,18 +7711,29 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag10 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag10,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag10, + ) + ) return matched - + return inner - + + parse_member_name_shorthand = _parse_member_name_shorthand() + def _parse_name_first() -> Callable[[ParserState, list[Pair]], bool]: - RE3 = re.compile('[_A-Za-z\x80-\ud7ff\ue000-\U0010ffff]', re.VERSION1) - - rule_frame = RuleFrame('name_first', 2) - + RE3 = re.compile("[_A-Za-z\x80-\ud7ff\ue000-\U0010ffff]", re.VERSION1) + + rule_frame = RuleFrame("name_first", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse name_first.""" state.rule_stack.push(rule_frame) @@ -7302,17 +7749,19 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'name_first' pairs.extend(children2) return matched - + return inner - + + parse_name_first = _parse_name_first() + def _parse_name_char() -> Callable[[ParserState, list[Pair]], bool]: - RE4 = re.compile('[_A-Za-z\x80-\ud7ff\ue000-\U0010ffff]', re.VERSION1) - RE5 = re.compile('[0-9]', re.I) - - rule_frame = RuleFrame('name_char', 2) - + RE4 = re.compile("[_A-Za-z\x80-\ud7ff\ue000-\U0010ffff]", re.VERSION1) + RE5 = re.compile("[0-9]", re.I) + + rule_frame = RuleFrame("name_char", 2) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse name_char.""" state.rule_stack.push(rule_frame) @@ -7356,14 +7805,16 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: # Silent rule 'name_char' pairs.extend(children2) return matched - + return inner - + + parse_name_char = _parse_name_char() + def _parse_descendant_segment() -> Callable[[ParserState, list[Pair]], bool]: - rule_frame = RuleFrame('descendant_segment', 0) - + rule_frame = RuleFrame("descendant_segment", 0) + def inner(state: ParserState, pairs: list[Pair]) -> bool: """Parse descendant_segment.""" pos1 = state.pos @@ -7374,7 +7825,7 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: if all_ok4: matched3 = False # - if state.input.startswith('..', state.pos): + if state.input.startswith("..", state.pos): state.pos += 2 matched3 = True else: @@ -7436,87 +7887,100 @@ def inner(state: ParserState, pairs: list[Pair]) -> bool: else: tag6 = None if matched: - pairs.append(Pair(state.input, pos1, state.pos, rule_frame, children2, tag6,)) + pairs.append( + Pair( + state.input, + pos1, + state.pos, + rule_frame, + children2, + tag6, + ) + ) return matched - + return inner - + + parse_descendant_segment = _parse_descendant_segment() + def parse_trivia(state: ParserState, pairs: list[Pair]) -> bool: return True + _RULE_MAP: dict[str, Callable[[ParserState, list[Pair]], bool]] = { - 'EOI': parse_EOI, - 'jsonpath': parse_jsonpath, - 'jsonpath_query': parse_jsonpath_query, - 'segments': parse_segments, - 'B': parse_B, - 'S': parse_S, - 'root_identifier': parse_root_identifier, - 'selector': parse_selector, - 'name_selector': parse_name_selector, - 'string_literal': parse_string_literal, - 'double_quoted': parse_double_quoted, - 'single_quoted': parse_single_quoted, - 'double_quoted_char': parse_double_quoted_char, - 'single_quoted_char': parse_single_quoted_char, - 'ESC': parse_ESC, - 'unescaped': parse_unescaped, - 'escapable': parse_escapable, - 'hexchar': parse_hexchar, - 'non_surrogate': parse_non_surrogate, - 'high_surrogate': parse_high_surrogate, - 'low_surrogate': parse_low_surrogate, - 'wildcard_selector': parse_wildcard_selector, - 'index_selector': parse_index_selector, - 'int': parse_int, - 'slice_selector': parse_slice_selector, - 'start': parse_start, - 'stop': parse_stop, - 'step': parse_step, - 'filter_selector': parse_filter_selector, - 'logical_expr': parse_logical_expr, - 'logical_or_expr': parse_logical_or_expr, - 'logical_and_expr': parse_logical_and_expr, - 'basic_expr': parse_basic_expr, - 'paren_expr': parse_paren_expr, - 'logical_not_op': parse_logical_not_op, - 'test_expr': parse_test_expr, - 'filter_query': parse_filter_query, - 'root_query': parse_root_query, - 'rel_query': parse_rel_query, - 'current_node_identifier': parse_current_node_identifier, - 'comparison_expr': parse_comparison_expr, - 'literal': parse_literal, - 'comparable': parse_comparable, - 'comparison_op': parse_comparison_op, - 'singular_query': parse_singular_query, - 'rel_singular_query': parse_rel_singular_query, - 'abs_singular_query': parse_abs_singular_query, - 'singular_query_segments': parse_singular_query_segments, - 'name_segment': parse_name_segment, - 'index_segment': parse_index_segment, - 'number': parse_number, - 'frac': parse_frac, - 'exp': parse_exp, - 'true_literal': parse_true_literal, - 'false_literal': parse_false_literal, - 'null': parse_null, - 'function_name': parse_function_name, - 'function_name_first': parse_function_name_first, - 'function_name_char': parse_function_name_char, - 'function_expr': parse_function_expr, - 'function_argument': parse_function_argument, - 'segment': parse_segment, - 'child_segment': parse_child_segment, - 'bracketed_selection': parse_bracketed_selection, - 'member_name_shorthand': parse_member_name_shorthand, - 'name_first': parse_name_first, - 'name_char': parse_name_char, - 'descendant_segment': parse_descendant_segment, + "EOI": parse_EOI, + "jsonpath": parse_jsonpath, + "jsonpath_query": parse_jsonpath_query, + "segments": parse_segments, + "B": parse_B, + "S": parse_S, + "root_identifier": parse_root_identifier, + "selector": parse_selector, + "name_selector": parse_name_selector, + "string_literal": parse_string_literal, + "double_quoted": parse_double_quoted, + "single_quoted": parse_single_quoted, + "double_quoted_char": parse_double_quoted_char, + "single_quoted_char": parse_single_quoted_char, + "ESC": parse_ESC, + "unescaped": parse_unescaped, + "escapable": parse_escapable, + "hexchar": parse_hexchar, + "non_surrogate": parse_non_surrogate, + "high_surrogate": parse_high_surrogate, + "low_surrogate": parse_low_surrogate, + "wildcard_selector": parse_wildcard_selector, + "index_selector": parse_index_selector, + "int": parse_int, + "slice_selector": parse_slice_selector, + "start": parse_start, + "stop": parse_stop, + "step": parse_step, + "filter_selector": parse_filter_selector, + "logical_expr": parse_logical_expr, + "logical_or_expr": parse_logical_or_expr, + "logical_and_expr": parse_logical_and_expr, + "basic_expr": parse_basic_expr, + "paren_expr": parse_paren_expr, + "logical_not_op": parse_logical_not_op, + "test_expr": parse_test_expr, + "filter_query": parse_filter_query, + "root_query": parse_root_query, + "rel_query": parse_rel_query, + "current_node_identifier": parse_current_node_identifier, + "comparison_expr": parse_comparison_expr, + "literal": parse_literal, + "comparable": parse_comparable, + "comparison_op": parse_comparison_op, + "singular_query": parse_singular_query, + "rel_singular_query": parse_rel_singular_query, + "abs_singular_query": parse_abs_singular_query, + "singular_query_segments": parse_singular_query_segments, + "name_segment": parse_name_segment, + "index_segment": parse_index_segment, + "number": parse_number, + "frac": parse_frac, + "exp": parse_exp, + "true_literal": parse_true_literal, + "false_literal": parse_false_literal, + "null": parse_null, + "function_name": parse_function_name, + "function_name_first": parse_function_name_first, + "function_name_char": parse_function_name_char, + "function_expr": parse_function_expr, + "function_argument": parse_function_argument, + "segment": parse_segment, + "child_segment": parse_child_segment, + "bracketed_selection": parse_bracketed_selection, + "member_name_shorthand": parse_member_name_shorthand, + "name_first": parse_name_first, + "name_char": parse_name_char, + "descendant_segment": parse_descendant_segment, } + def parse(start_rule: str, text: str, *, start_pos: int = 0) -> Pairs: """Parse the given `text` starting from the specified `start_rule`. @@ -7539,12 +8003,15 @@ def parse(start_rule: str, text: str, *, start_pos: int = 0) -> Pairs: return Pairs(pairs) raise PestParsingError(state) + class Parser: """A class wrapping `parse()` in `Parser.parse()`.""" + def parse(self, start_rule: str, text: str, *, start_pos: int = 0) -> Pairs: """Parse the given `text` starting from the specified `start_rule`.""" return parse(start_rule, text, start_pos=start_pos) + def main() -> None: parser = argparse.ArgumentParser( prog="parser", @@ -7587,6 +8054,8 @@ def main() -> None: parse(args.rule, text).dumps(compact=not args.verbose) ) + if __name__ == "__main__": import argparse + main() diff --git a/tests/grammars/grammar.pest b/tests/grammars/grammar.pest index 5d64d5d..c176222 100644 --- a/tests/grammars/grammar.pest +++ b/tests/grammars/grammar.pest @@ -1,94 +1,92 @@ // pest. The Elegant Parser // Copyright (c) 2018 Dragoș Tiselice -// +// // Licensed under the Apache License, Version 2.0 // or the MIT // license , at your // option. All files in the project carrying such notice may not be copied, // modified, or distributed except according to those terms. -string = { "abc" } -insensitive = { ^"abc" } -range = { '0'..'9' } -ident = { string } -pos_pred = { &string } -neg_pred = { !string } -double_neg_pred = { !!string } -sequence = !{ string ~ string } -sequence_compound = ${ string ~ string } -sequence_atomic = @{ string ~ string } -sequence_non_atomic = @{ sequence } -sequence_atomic_compound = @{ sequence_compound } -sequence_nested = { string ~ string } -sequence_compound_nested = ${ sequence_nested } -node_tag = { #string = string } -choice = { string | range } -choice_prefix = { | string | range } -optional = { string? } -repeat = { string* } -repeat_atomic = @{ string* } -repeat_once = { string+ } -repeat_once_atomic = @{ string+ } -repeat_min_max = { string{2, 3} } -repeat_min_max_atomic = @{ string{2, 3} } -repeat_exact = { string{2} } -repeat_min = { string{2,} } -repeat_min_atomic = @{ string{2,} } -repeat_max = { string{, 2} } -repeat_max_atomic = @{ string{, 2} } -soi_at_start = { SOI ~ string } -repeat_mutate_stack = { (PUSH('a'..'c') ~ ",")* ~ POP ~ POP ~ POP } -repeat_mutate_stack_pop_all = { (PUSH('a'..'c') ~ ",")* ~ POP_ALL } -will_fail = { repeat_mutate_stack_pop_all ~ "FAIL" } -stack_resume_after_fail = { will_fail | repeat_mutate_stack_pop_all } -peek_ = { PUSH(range) ~ PUSH(range) ~ PEEK ~ PEEK } -peek_all = { PUSH(range) ~ PUSH(range) ~ PEEK_ALL } -peek_slice_23 = { PUSH(range) ~ PUSH(range) ~ PUSH(range) ~ PUSH(range) ~ PUSH(range) ~ PEEK[1..-2] } -pop_ = { PUSH(range) ~ PUSH(range) ~ POP ~ POP } -pop_all = { PUSH(range) ~ PUSH(range) ~ POP_ALL } -pop_fail = { PUSH(range) ~ !POP ~ range ~ POP } -checkpoint_restore = ${ - PUSH("") ~ (PUSH("a") ~ "b" ~ POP | DROP ~ "b" | POP ~ "a") ~ EOI +string = { "abc" } +insensitive = { ^"abc" } +range = { '0'..'9' } +ident = { string } +pos_pred = { &string } +neg_pred = { !string } +double_neg_pred = { !!string } +sequence = !{ string ~ string } +sequence_compound = ${ string ~ string } +sequence_atomic = @{ string ~ string } +sequence_non_atomic = @{ sequence } +sequence_atomic_compound = @{ sequence_compound } +sequence_nested = { string ~ string } +sequence_compound_nested = ${ sequence_nested } +node_tag = { #string = string } +choice = { string | range } +choice_prefix = { | string | range } +optional = { string? } +repeat = { string* } +repeat_atomic = @{ string* } +repeat_once = { string+ } +repeat_once_atomic = @{ string+ } +repeat_min_max = { string{2, 3} } +repeat_min_max_atomic = @{ string{2, 3} } +repeat_exact = { string{2} } +repeat_min = { string{2, } } +repeat_min_atomic = @{ string{2, } } +repeat_max = { string{, 2} } +repeat_max_atomic = @{ string{, 2} } +soi_at_start = { SOI ~ string } +repeat_mutate_stack = { (PUSH('a'..'c') ~ ",")* ~ POP ~ POP ~ POP } +repeat_mutate_stack_pop_all = { (PUSH('a'..'c') ~ ",")* ~ POP_ALL } +will_fail = { repeat_mutate_stack_pop_all ~ "FAIL" } +stack_resume_after_fail = { will_fail | repeat_mutate_stack_pop_all } +peek_ = { PUSH(range) ~ PUSH(range) ~ PEEK ~ PEEK } +peek_all = { PUSH(range) ~ PUSH(range) ~ PEEK_ALL } +peek_slice_23 = { PUSH(range) ~ PUSH(range) ~ PUSH(range) ~ PUSH(range) ~ PUSH(range) ~ PEEK[1..-2] } +pop_ = { PUSH(range) ~ PUSH(range) ~ POP ~ POP } +pop_all = { PUSH(range) ~ PUSH(range) ~ POP_ALL } +pop_fail = { PUSH(range) ~ !POP ~ range ~ POP } +checkpoint_restore = ${ + PUSH("") ~ (PUSH("a") ~ "b" ~ POP | DROP ~ "b" | POP ~ "a") ~ EOI } -ascii_digits = { ASCII_DIGIT+ } -ascii_nonzero_digits = { ASCII_NONZERO_DIGIT+ } -ascii_bin_digits = { ASCII_BIN_DIGIT+ } -ascii_oct_digits = { ASCII_OCT_DIGIT+ } -ascii_hex_digits = { ASCII_HEX_DIGIT+ } -ascii_alpha_lowers = { ASCII_ALPHA_LOWER+ } -ascii_alpha_uppers = { ASCII_ALPHA_UPPER+ } -ascii_alphas = { ASCII_ALPHA+ } -ascii_alphanumerics = { ASCII_ALPHANUMERIC+ } -asciis = { ASCII+ } -newline = { NEWLINE+ } -unicode = { XID_START ~ XID_CONTINUE* } -SYMBOL = { "shadows builtin" } +ascii_digits = { ASCII_DIGIT+ } +ascii_nonzero_digits = { ASCII_NONZERO_DIGIT+ } +ascii_bin_digits = { ASCII_BIN_DIGIT+ } +ascii_oct_digits = { ASCII_OCT_DIGIT+ } +ascii_hex_digits = { ASCII_HEX_DIGIT+ } +ascii_alpha_lowers = { ASCII_ALPHA_LOWER+ } +ascii_alpha_uppers = { ASCII_ALPHA_UPPER+ } +ascii_alphas = { ASCII_ALPHA+ } +ascii_alphanumerics = { ASCII_ALPHANUMERIC+ } +asciis = { ASCII+ } +newline = { NEWLINE+ } +unicode = { XID_START ~ XID_CONTINUE* } +SYMBOL = { "shadows builtin" } -han = { HAN+ } -hangul = { HANGUL+ } +han = { HAN+ } +hangul = { HANGUL+ } hiragana = { HIRAGANA+ } -arabic = { ARABIC+ } -emoji = { EMOJI+ } +arabic = { ARABIC+ } +emoji = { EMOJI+ } WHITESPACE = _{ " " } -COMMENT = _{ "$"+ } +COMMENT = _{ "$"+ } // Line comment /* 1-line multiline comment */ -/* - N-line multiline comment -*/ +/* N-line multiline comment */ /* - // Line comment inside multiline + // Line comment inside multiline - /* - (Multiline inside) multiline - */ + /* + (Multiline inside) multiline + */ - Invalid segment of grammar below (repeated rule) + Invalid segment of grammar below (repeated rule) - WHITESPACE = _{ "hi" } + WHITESPACE = _{ "hi" } */ diff --git a/tests/grammars/http.pest b/tests/grammars/http.pest index 623c937..05de52e 100644 --- a/tests/grammars/http.pest +++ b/tests/grammars/http.pest @@ -1,20 +1,18 @@ -http = { SOI ~ (delimiter | request)* ~ EOI} +http = { SOI ~ (delimiter | request)* ~ EOI } -request = { - request_line ~ - headers? ~ - NEWLINE +request = { + request_line ~ headers? ~ NEWLINE } request_line = _{ method ~ " "+ ~ uri ~ " "+ ~ "HTTP/" ~ version ~ NEWLINE } -uri = { (!whitespace ~ ANY)+ } -method = { ("GET" | "DELETE" | "POST" | "PUT") } -version = { (ASCII_DIGIT | ".")+ } -whitespace = _{ " " | "\t" } +uri = { (!whitespace ~ ANY)+ } +method = { ("GET" | "DELETE" | "POST" | "PUT") } +version = { (ASCII_DIGIT | ".")+ } +whitespace = _{ " " | "\t" } -headers = { header+ } -header = { header_name ~ ":" ~ whitespace ~ header_value ~ NEWLINE } -header_name = { (!(NEWLINE | ":") ~ ANY)+ } +headers = { header+ } +header = { header_name ~ ":" ~ whitespace ~ header_value ~ NEWLINE } +header_name = { (!(NEWLINE | ":") ~ ANY)+ } header_value = { (!NEWLINE ~ ANY)+ } -delimiter = { NEWLINE+ } \ No newline at end of file +delimiter = { NEWLINE+ } diff --git a/tests/grammars/json.pest b/tests/grammars/json.pest index 60c3a65..0c74de2 100644 --- a/tests/grammars/json.pest +++ b/tests/grammars/json.pest @@ -1,6 +1,6 @@ // pest. The Elegant Parser // Copyright (c) 2018 Dragoș Tiselice -// +// // Licensed under the Apache License, Version 2.0 // or the MIT // license , at your @@ -19,10 +19,9 @@ pair = { string ~ ":" ~ value } array = { "[" ~ value ~ ("," ~ value)* ~ "]" | "[" ~ "]" } - -////////////////////// +/// / /// Matches value, e.g.: `"foo"`, `42`, `true`, `null`, `[]`, `{}`. -////////////////////// +/// / value = { string | number | object | array | bool | null } string = @{ "\"" ~ inner ~ "\"" } diff --git a/tests/grammars/lists.pest b/tests/grammars/lists.pest index 47756b7..65e0677 100644 --- a/tests/grammars/lists.pest +++ b/tests/grammars/lists.pest @@ -1,6 +1,6 @@ // pest. The Elegant Parser // Copyright (c) 2018 Dragoș Tiselice -// +// // Licensed under the Apache License, Version 2.0 // or the MIT // license , at your diff --git a/tests/grammars/reporting.pest b/tests/grammars/reporting.pest index 060dbfc..f02af2a 100644 --- a/tests/grammars/reporting.pest +++ b/tests/grammars/reporting.pest @@ -1,6 +1,6 @@ // pest. The Elegant Parser // Copyright (c) 2018 Dragoș Tiselice -// +// // Licensed under the Apache License, Version 2.0 // or the MIT // license , at your @@ -12,16 +12,15 @@ b = { "b" } c = { "c" } d = { ANY } -choices = _{ a | b | c } -choices_no_progress = { a | b | c } -choices_a_progress = { a ~ a | b | c } -choices_b_progress = { a | b ~ b | c } +choices = _{ a | b | c } +choices_no_progress = { a | b | c } +choices_a_progress = { a ~ a | b | c } +choices_b_progress = { a | b ~ b | c } level1 = _{ level2 } level2 = _{ a | b | c } -negative = _{ !d } +negative = _{ !d } negative_match = _{ !a ~ b } -mixed = _{ !d | a } +mixed = _{ !d | a } mixed_progress = _{ (!d | a | b) ~ a } - diff --git a/tests/grammars/sql.pest b/tests/grammars/sql.pest index eea9617..34bd624 100644 --- a/tests/grammars/sql.pest +++ b/tests/grammars/sql.pest @@ -1,190 +1,213 @@ Command = _{ SOI ~ (Query | ExplainQuery | DDL | ACL) ~ EOF } -ACL = _{ DropRole | DropUser | CreateRole | CreateUser | AlterUser | GrantPrivilege | RevokePrivilege } - CreateUser = { - ^"create" ~ ^"user" ~ Identifier ~ (^"with")? ~ ^"password" ~ SingleQuotedString ~ - AuthMethod? - } - AlterUser = { - ^"alter" ~ ^"user" ~ Identifier ~ (^"with")? ~ AlterOption - } - AlterOption = _{ AlterLogin | AlterNoLogin | AlterPassword } - AlterLogin = { ^"login" } - AlterNoLogin = { ^"nologin" } - AlterPassword = { ^"password" ~ SingleQuotedString ~ AuthMethod? } - AuthMethod = { ^"using" ~ (ChapSha1 | Md5 | Ldap) } - ChapSha1 = { ^"chap-sha1" } - Md5 = { ^"md5" } - Ldap = { ^"ldap" } - DropUser = { ^"drop" ~ ^"user" ~ Identifier } - CreateRole = { ^"create" ~ ^"role" ~ Identifier } - DropRole = { ^"drop" ~ ^"role" ~ Identifier } - GrantPrivilege = { ^"grant" ~ PrivBlock ~ ^"to" ~ Identifier } - RevokePrivilege = { ^"revoke" ~ PrivBlock ~ ^"from" ~ Identifier } - PrivBlock = _{ PrivBlockPrivilege | PrivBlockRolePass } - PrivBlockPrivilege = {Privilege ~ (PrivBlockUser | PrivBlockSpecificUser | PrivBlockRole - | PrivBlockSpecificRole | PrivBlockTable | PrivBlockSpecificTable)} - PrivBlockUser = { ^"user" } - PrivBlockSpecificUser = { ^"on" ~ ^"user" ~ Identifier } - PrivBlockRole = { ^"role" } - PrivBlockSpecificRole = { ^"on" ~ ^"role" ~ Identifier } - PrivBlockTable = { ^"table" } - PrivBlockSpecificTable = { ^"on" ~ ^"table" ~ Identifier } - PrivBlockRolePass = { Identifier } - Privilege = _{ PrivilegeRead | PrivilegeWrite | PrivilegeExecute | - PrivilegeCreate | PrivilegeAlter | PrivilegeDrop | - PrivilegeSession | PrivilegeUsage } - PrivilegeAlter = { ^"alter" } - PrivilegeCreate = { ^"create" } - PrivilegeDrop = { ^"drop" } - PrivilegeExecute = { ^"execute" } - PrivilegeRead = { ^"read" } - PrivilegeSession = { ^"session" } - PrivilegeUsage = { ^"usage" } - PrivilegeWrite = { ^"write" } +ACL = _{ DropRole | DropUser | CreateRole | CreateUser | AlterUser | GrantPrivilege | RevokePrivilege } +CreateUser = { + ^"create" ~ ^"user" ~ Identifier ~ (^"with")? ~ ^"password" ~ SingleQuotedString ~ AuthMethod? +} +AlterUser = { + ^"alter" ~ ^"user" ~ Identifier ~ (^"with")? ~ AlterOption +} +AlterOption = _{ AlterLogin | AlterNoLogin | AlterPassword } +AlterLogin = { ^"login" } +AlterNoLogin = { ^"nologin" } +AlterPassword = { ^"password" ~ SingleQuotedString ~ AuthMethod? } +AuthMethod = { ^"using" ~ (ChapSha1 | Md5 | Ldap) } +ChapSha1 = { ^"chap-sha1" } +Md5 = { ^"md5" } +Ldap = { ^"ldap" } +DropUser = { ^"drop" ~ ^"user" ~ Identifier } +CreateRole = { ^"create" ~ ^"role" ~ Identifier } +DropRole = { ^"drop" ~ ^"role" ~ Identifier } +GrantPrivilege = { ^"grant" ~ PrivBlock ~ ^"to" ~ Identifier } +RevokePrivilege = { ^"revoke" ~ PrivBlock ~ ^"from" ~ Identifier } +PrivBlock = _{ PrivBlockPrivilege | PrivBlockRolePass } +PrivBlockPrivilege = { + Privilege ~ (PrivBlockUser | PrivBlockSpecificUser | PrivBlockRole | PrivBlockSpecificRole | PrivBlockTable | PrivBlockSpecificTable) +} +PrivBlockUser = { ^"user" } +PrivBlockSpecificUser = { ^"on" ~ ^"user" ~ Identifier } +PrivBlockRole = { ^"role" } +PrivBlockSpecificRole = { ^"on" ~ ^"role" ~ Identifier } +PrivBlockTable = { ^"table" } +PrivBlockSpecificTable = { ^"on" ~ ^"table" ~ Identifier } +PrivBlockRolePass = { Identifier } +Privilege = _{ + PrivilegeRead + | PrivilegeWrite + | PrivilegeExecute + | PrivilegeCreate + | PrivilegeAlter + | PrivilegeDrop + | PrivilegeSession + | PrivilegeUsage +} +PrivilegeAlter = { ^"alter" } +PrivilegeCreate = { ^"create" } +PrivilegeDrop = { ^"drop" } +PrivilegeExecute = { ^"execute" } +PrivilegeRead = { ^"read" } +PrivilegeSession = { ^"session" } +PrivilegeUsage = { ^"usage" } +PrivilegeWrite = { ^"write" } -DDL = _{ CreateTable | DropTable | CreateProc } - CreateTable = { - ^"create" ~ ^"table" ~ Identifier ~ - "(" ~ Columns ~ "," ~ PrimaryKey ~ ")" ~ - Distribution - } - Columns = { ColumnDef ~ ("," ~ ColumnDef)* } - ColumnDef = { Identifier ~ ColumnDefType ~ ColumnDefIsNull? } - ColumnDefIsNull = { NotFlag? ~ ^"null" } - PrimaryKey = { - ^"primary" ~ ^"key" ~ - "(" ~ Identifier ~ ("," ~ Identifier)* ~ ")" - } - Distribution = { ^"distributed" ~ (Global | Sharding) } - Global = { ^"globally" } - Sharding = { ^"by" ~ "(" ~ Identifier ~ ("," ~ Identifier)* ~ ")"} - DropTable = { ^"drop" ~ ^"table" ~ Identifier } +DDL = _{ CreateTable | DropTable | CreateProc } +CreateTable = { + ^"create" ~ ^"table" ~ Identifier ~ "(" ~ Columns ~ "," ~ PrimaryKey ~ ")" ~ Distribution +} +Columns = { ColumnDef ~ ("," ~ ColumnDef)* } +ColumnDef = { Identifier ~ ColumnDefType ~ ColumnDefIsNull? } +ColumnDefIsNull = { NotFlag? ~ ^"null" } +PrimaryKey = { + ^"primary" ~ ^"key" ~ "(" ~ Identifier ~ ("," ~ Identifier)* ~ ")" +} +Distribution = { ^"distributed" ~ (Global | Sharding) } +Global = { ^"globally" } +Sharding = { ^"by" ~ "(" ~ Identifier ~ ("," ~ Identifier)* ~ ")" } +DropTable = { ^"drop" ~ ^"table" ~ Identifier } - CreateProc = { - ^"create" ~ ^"procedure" ~ Identifier ~ - "(" ~ ProcParams? ~ ")" ~ (^"language" ~ ProcLanguage)? ~ - ((^"as" ~ "$$" ~ ProcBody ~ "$$") | (^"begin" ~ "atomic" ~ ProcBody ~ "end")) - } - ProcParams = { ProcParamDef ~ ("," ~ ProcParamDef)* } - ProcParamDef = { ColumnDefType } - ProcLanguage = { SQL } - SQL = { ^"sql" } - ProcBody = { (Insert | Update | Delete) } +CreateProc = { + ^"create" ~ ^"procedure" ~ Identifier ~ "(" ~ ProcParams? ~ ")" ~ (^"language" ~ ProcLanguage)? ~ ((^"as" ~ "$$" ~ ProcBody ~ "$$") | (^"begin" ~ "atomic" ~ ProcBody ~ "end")) +} +ProcParams = { ProcParamDef ~ ("," ~ ProcParamDef)* } +ProcParamDef = { ColumnDefType } +ProcLanguage = { SQL } +SQL = { ^"sql" } +ProcBody = { (Insert | Update | Delete) } ExplainQuery = _{ Explain } - Explain = { ^"explain" ~ Query } +Explain = { ^"explain" ~ Query } -Query = { (SelectWithOptionalContinuation | Values | Insert | Update | Delete) } - SelectWithOptionalContinuation = { Select ~ (ExceptContinuation | UnionAllContinuation)? } - ExceptContinuation = { ((^"except" ~ ^"distinct") | ^"except") ~ Select } - UnionAllContinuation = { ^"union" ~ ^"all" ~ Select } - Select = { - ^"select" ~ Projection ~ ^"from" ~ Scan ~ - Join? ~ WhereClause? ~ - (^"group" ~ ^"by" ~ GroupBy)? ~ - (^"having" ~ Having)? - } - Projection = { Distinct? ~ ProjectionElement ~ ("," ~ ProjectionElement)* } - ProjectionElement = _{ Asterisk | Column } - Column = { Expr ~ ((^"as")? ~ Identifier)? } - Asterisk = { "*" } - WhereClause = _{ ^"where" ~ Selection } - Selection = { Expr } - Scan = { (Identifier | SubQuery) ~ ((^"as")? ~ Identifier)? } - Join = { JoinKind? ~ ^"join" ~ Scan ~ ^"on" ~ Expr } - JoinKind = _{ ( InnerJoinKind | LeftJoinKind ) } - InnerJoinKind = { ^"inner" } - LeftJoinKind = { ^"left" ~ (^"outer")? } - GroupBy = { Expr ~ ("," ~ Expr)* } - Having = { Expr } - SubQuery = { "(" ~ (SelectWithOptionalContinuation | Values) ~ ")" } - Insert = { ^"insert" ~ ^"into" ~ Identifier ~ ("(" ~ TargetColumns ~ ")")? ~ (Values | Select) ~ OnConflict? } - TargetColumns = { Identifier ~ ("," ~ Identifier)* } - OnConflict = _{ ^"on conflict" ~ ^"do" ~ (DoNothing | DoReplace | DoFail) } - DoReplace = { ^"replace" } - DoNothing = { ^"nothing" } - DoFail = { ^"fail" } - Update = { ^"update" ~ Identifier ~ ^"set" ~ UpdateList ~ (UpdateFrom | WhereClause)? } - UpdateList = { UpdateItem ~ ("," ~ UpdateItem)* } - UpdateItem = { Identifier ~ "=" ~ Expr } - UpdateFrom = _{ ^"from" ~ Scan ~ (^"where" ~ Expr)? } - Values = { ^"values" ~ Row ~ ("," ~ Row)* } - Delete = { ^"delete" ~ ^"from" ~ Identifier ~ (^"where" ~ DeleteFilter)? } - DeleteFilter = { Expr } +Query = { (SelectWithOptionalContinuation | Values | Insert | Update | Delete) } +SelectWithOptionalContinuation = { Select ~ (ExceptContinuation | UnionAllContinuation)? } +ExceptContinuation = { ((^"except" ~ ^"distinct") | ^"except") ~ Select } +UnionAllContinuation = { ^"union" ~ ^"all" ~ Select } +Select = { + ^"select" ~ Projection ~ ^"from" ~ Scan ~ Join? ~ WhereClause? ~ (^"group" ~ ^"by" ~ GroupBy)? ~ (^"having" ~ Having)? +} +Projection = { Distinct? ~ ProjectionElement ~ ("," ~ ProjectionElement)* } +ProjectionElement = _{ Asterisk | Column } +Column = { Expr ~ ((^"as")? ~ Identifier)? } +Asterisk = { "*" } +WhereClause = _{ ^"where" ~ Selection } +Selection = { Expr } +Scan = { (Identifier | SubQuery) ~ ((^"as")? ~ Identifier)? } +Join = { JoinKind? ~ ^"join" ~ Scan ~ ^"on" ~ Expr } +JoinKind = _{ (InnerJoinKind | LeftJoinKind) } +InnerJoinKind = { ^"inner" } +LeftJoinKind = { ^"left" ~ (^"outer")? } +GroupBy = { Expr ~ ("," ~ Expr)* } +Having = { Expr } +SubQuery = { "(" ~ (SelectWithOptionalContinuation | Values) ~ ")" } +Insert = { ^"insert" ~ ^"into" ~ Identifier ~ ("(" ~ TargetColumns ~ ")")? ~ (Values | Select) ~ OnConflict? } +TargetColumns = { Identifier ~ ("," ~ Identifier)* } +OnConflict = _{ ^"on conflict" ~ ^"do" ~ (DoNothing | DoReplace | DoFail) } +DoReplace = { ^"replace" } +DoNothing = { ^"nothing" } +DoFail = { ^"fail" } +Update = { ^"update" ~ Identifier ~ ^"set" ~ UpdateList ~ (UpdateFrom | WhereClause)? } +UpdateList = { UpdateItem ~ ("," ~ UpdateItem)* } +UpdateItem = { Identifier ~ "=" ~ Expr } +UpdateFrom = _{ ^"from" ~ Scan ~ (^"where" ~ Expr)? } +Values = { ^"values" ~ Row ~ ("," ~ Row)* } +Delete = { ^"delete" ~ ^"from" ~ Identifier ~ (^"where" ~ DeleteFilter)? } +DeleteFilter = { Expr } -Identifier = @{ DoubleQuotedIdentifier | IdentifierInner } - DoubleQuotedIdentifier = @{ ("\"" ~ IdentifierInner ~ "\"") } - IdentifierInner = @{ !(Keyword ~ ("(" | WHITESPACE | "," | EOF)) ~ (IdentifierNonDigit ~ (IdentifierNonDigit | ASCII_DIGIT)*) } - IdentifierNonDigit = _{ ('a'..'z' | 'A' .. 'Z' | 'А' .. 'Я' | 'а' .. 'я' | "-" | "_") } - Keyword = { ^"left" | ^"having" | ^"not" | ^"inner" | ^"group" - | ^"on" | ^"join" | ^"from" | ^"exists" | ^"except" - | ^"union" | ^"where" | ^"distinct" | ^"between" | ^"option" - | ^"values"} +Identifier = @{ DoubleQuotedIdentifier | IdentifierInner } +DoubleQuotedIdentifier = @{ ("\"" ~ IdentifierInner ~ "\"") } +IdentifierInner = @{ !(Keyword ~ ("(" | WHITESPACE | "," | EOF)) ~ (IdentifierNonDigit ~ (IdentifierNonDigit | ASCII_DIGIT)*) } +IdentifierNonDigit = _{ ('a'..'z' | 'A' .. 'Z' | 'А' .. 'Я' | 'а' .. 'я' | "-" | "_") } +Keyword = { + ^"left" + | ^"having" + | ^"not" + | ^"inner" + | ^"group" + | ^"on" + | ^"join" + | ^"from" + | ^"exists" + | ^"except" + | ^"union" + | ^"where" + | ^"distinct" + | ^"between" + | ^"option" + | ^"values" +} -Expr = { ExprAtomValue ~ (ExprInfixOp ~ ExprAtomValue)* } - ExprInfixOp = _{ Between | ArithInfixOp | CmpInfixOp | ConcatInfixOp | And | Or } - Between = { NotFlag? ~ ^"between" } - And = { ^"and" } - Or = { ^"or" } - ConcatInfixOp = { "||" } - ArithInfixOp = _{ Add | Subtract | Multiply | Divide } - Add = { "+" } - Subtract = { "-" } - Multiply = { "*" } - Divide = { "/" } - CmpInfixOp = _{ NotEq | GtEq | Gt | LtEq | Lt | Eq | Lt | In } - Eq = { "=" } - Gt = { ">" } - GtEq = { ">=" } - Lt = { "<" } - LtEq = { "<=" } - NotEq = { "<>" | "!=" } - In = { NotFlag? ~ ^"in" } - ExprAtomValue = _{ UnaryNot* ~ AtomicExpr ~ IsNullPostfix? } - UnaryNot = @{ NotFlag } - IsNullPostfix = { ^"is" ~ NotFlag? ~ ^"null" } - AtomicExpr = _{ Literal | Parameter | Cast | IdentifierWithOptionalContinuation | ExpressionInParentheses | UnaryOperator | SubQuery | Row } - Literal = _{ True | False | Null | Double | Decimal | Unsigned | Integer | SingleQuotedString } - True = { ^"true" } - False = { ^"false" } - Null = { ^"null" } - Decimal = @{ Integer ~ ("." ~ ASCII_DIGIT*) } - Double = @{ Integer ~ ("." ~ ASCII_DIGIT*)? ~ (^"e" ~ Integer) } - Integer = @{ ("+" | "-")? ~ ASCII_DIGIT+ } - Unsigned = @{ ASCII_DIGIT+ } - SingleQuotedString = @{ OnlyQuotesSequence | AnythingButQuotesSequence } - OnlyQuotesSequence = @{ ("'" ~ "'")+ } - AnythingButQuotesSequence = @{ "'" ~ (!("'") ~ ANY)* ~ "'" } - Parameter = { PgParameter | QuestionParameter } - QuestionParameter = @{ "?" } - PgParameter = { "$" ~ Unsigned } - IdentifierWithOptionalContinuation = { Identifier ~ (ReferenceContinuation | FunctionInvocationContinuation)? } - ReferenceContinuation = { "." ~ Identifier } - FunctionInvocationContinuation = { "(" ~ (CountAsterisk | FunctionArgs)? ~ ")" } - FunctionArgs = { Distinct? ~ (Expr ~ ("," ~ Expr)*)? } - CountAsterisk = { "*" } - ExpressionInParentheses = { "(" ~ Expr ~ ")" } - Cast = { ^"cast" ~ "(" ~ Expr ~ ^"as" ~ TypeCast ~ ")" } - TypeCast = _{ TypeAny | ColumnDefType } - ColumnDefType = { TypeBool | TypeDecimal | TypeDouble | TypeInt | TypeNumber - | TypeScalar | TypeString | TypeText | TypeUnsigned | TypeVarchar } - TypeAny = { ^"any" } - TypeBool = { (^"boolean" | ^"bool") } - TypeDecimal = { ^"decimal" } - TypeDouble = { ^"double" } - TypeInt = { (^"integer" | ^"int") } - TypeNumber = { ^"number" } - TypeScalar = { ^"scalar" } - TypeString = { ^"string" } - TypeText = { ^"text" } - TypeUnsigned = { ^"unsigned" } - TypeVarchar = { ^"varchar" ~ "(" ~ Unsigned ~ ")" } - UnaryOperator = _{ Exists } - Exists = { NotFlag? ~ ^"exists" ~ SubQuery } - Row = { "(" ~ Expr ~ ("," ~ Expr)* ~ ")" } +Expr = { ExprAtomValue ~ (ExprInfixOp ~ ExprAtomValue)* } +ExprInfixOp = _{ Between | ArithInfixOp | CmpInfixOp | ConcatInfixOp | And | Or } +Between = { NotFlag? ~ ^"between" } +And = { ^"and" } +Or = { ^"or" } +ConcatInfixOp = { "||" } +ArithInfixOp = _{ Add | Subtract | Multiply | Divide } +Add = { "+" } +Subtract = { "-" } +Multiply = { "*" } +Divide = { "/" } +CmpInfixOp = _{ NotEq | GtEq | Gt | LtEq | Lt | Eq | Lt | In } +Eq = { "=" } +Gt = { ">" } +GtEq = { ">=" } +Lt = { "<" } +LtEq = { "<=" } +NotEq = { "<>" | "!=" } +In = { NotFlag? ~ ^"in" } +ExprAtomValue = _{ UnaryNot* ~ AtomicExpr ~ IsNullPostfix? } +UnaryNot = @{ NotFlag } +IsNullPostfix = { ^"is" ~ NotFlag? ~ ^"null" } +AtomicExpr = _{ Literal | Parameter | Cast | IdentifierWithOptionalContinuation | ExpressionInParentheses | UnaryOperator | SubQuery | Row } +Literal = _{ True | False | Null | Double | Decimal | Unsigned | Integer | SingleQuotedString } +True = { ^"true" } +False = { ^"false" } +Null = { ^"null" } +Decimal = @{ Integer ~ ("." ~ ASCII_DIGIT*) } +Double = @{ Integer ~ ("." ~ ASCII_DIGIT*)? ~ (^"e" ~ Integer) } +Integer = @{ ("+" | "-")? ~ ASCII_DIGIT+ } +Unsigned = @{ ASCII_DIGIT+ } +SingleQuotedString = @{ OnlyQuotesSequence | AnythingButQuotesSequence } +OnlyQuotesSequence = @{ ("'" ~ "'")+ } +AnythingButQuotesSequence = @{ "'" ~ (!("'") ~ ANY)* ~ "'" } +Parameter = { PgParameter | QuestionParameter } +QuestionParameter = @{ "?" } +PgParameter = { "$" ~ Unsigned } +IdentifierWithOptionalContinuation = { Identifier ~ (ReferenceContinuation | FunctionInvocationContinuation)? } +ReferenceContinuation = { "." ~ Identifier } +FunctionInvocationContinuation = { "(" ~ (CountAsterisk | FunctionArgs)? ~ ")" } +FunctionArgs = { Distinct? ~ (Expr ~ ("," ~ Expr)*)? } +CountAsterisk = { "*" } +ExpressionInParentheses = { "(" ~ Expr ~ ")" } +Cast = { ^"cast" ~ "(" ~ Expr ~ ^"as" ~ TypeCast ~ ")" } +TypeCast = _{ TypeAny | ColumnDefType } +ColumnDefType = { + TypeBool + | TypeDecimal + | TypeDouble + | TypeInt + | TypeNumber + | TypeScalar + | TypeString + | TypeText + | TypeUnsigned + | TypeVarchar +} +TypeAny = { ^"any" } +TypeBool = { (^"boolean" | ^"bool") } +TypeDecimal = { ^"decimal" } +TypeDouble = { ^"double" } +TypeInt = { (^"integer" | ^"int") } +TypeNumber = { ^"number" } +TypeScalar = { ^"scalar" } +TypeString = { ^"string" } +TypeText = { ^"text" } +TypeUnsigned = { ^"unsigned" } +TypeVarchar = { ^"varchar" ~ "(" ~ Unsigned ~ ")" } +UnaryOperator = _{ Exists } +Exists = { NotFlag? ~ ^"exists" ~ SubQuery } +Row = { "(" ~ Expr ~ ("," ~ Expr)* ~ ")" } -Distinct = { ^"distinct" } -NotFlag = { ^"not" } -EOF = { EOI | ";" } +Distinct = { ^"distinct" } +NotFlag = { ^"not" } +EOF = { EOI | ";" } WHITESPACE = _{ " " | "\t" | "\n" | "\r\n" } diff --git a/tests/grammars/toml.pest b/tests/grammars/toml.pest index b929cef..2bbde14 100644 --- a/tests/grammars/toml.pest +++ b/tests/grammars/toml.pest @@ -1,6 +1,6 @@ // pest. The Elegant Parser // Copyright (c) 2018 Dragoș Tiselice -// +// // Licensed under the Apache License, Version 2.0 // or the MIT // license , at your @@ -15,19 +15,19 @@ pair = { key ~ "=" ~ value } key = @{ identifier | string | literal } value = _{ - inline_table | - array | - multi_line_string | - string | - multi_line_literal | - literal | - date_time | - local_date_time | - full_date | - partial_time | - float | - integer | - boolean + inline_table + | array + | multi_line_string + | string + | multi_line_literal + | literal + | date_time + | local_date_time + | full_date + | partial_time + | float + | integer + | boolean } inline_table = { "{" ~ pair ~ ("," ~ pair)* ~ ","? ~ "}" | "{" ~ "}" }