#!/usr/bin/python3 ####################################################################### # # SYMBOLS SECTION - Can be edited. Changes will be preserved. # ####################################################################### import collections from functools import partial import os import sys sys.path.append(r'/home/eckhart/Entwicklung/DHParser') try: import regex as re except ImportError: import re from DHParser import logging, is_filename, load_if_file, \ Grammar, Compiler, nil_preprocessor, PreprocessorToken, Whitespace, DropWhitespace, \ Lookbehind, Lookahead, Alternative, Pop, Token, DropToken, Synonym, AllOf, SomeOf, \ Unordered, Option, NegativeLookbehind, OneOrMore, RegExp, Retrieve, Series, Capture, \ ZeroOrMore, Forward, NegativeLookahead, Required, mixin_comment, compile_source, \ grammar_changed, last_value, counterpart, PreprocessorFunc, is_empty, \ Node, TransformationFunc, TransformationDict, transformation_factory, traverse, \ remove_children_if, move_adjacent, normalize_whitespace, is_anonymous, matches_re, \ reduce_single_child, replace_by_single_child, replace_or_reduce, remove_whitespace, \ replace_by_children, remove_empty, remove_tokens, flatten, is_insignificant_whitespace, \ collapse, collapse_if, replace_content, WHITESPACE_PTYPE, TOKEN_PTYPE, \ remove_nodes, remove_content, remove_brackets, change_tag_name, remove_anonymous_tokens, \ keep_children, is_one_of, not_one_of, has_content, apply_if, remove_first, remove_last, \ remove_anonymous_empty, keep_nodes, traverse_locally, strip, lstrip, rstrip, \ replace_content, replace_content_by, forbid, assert_content, remove_infix_operator, \ error_on, recompile_grammar, left_associative, lean_left, GLOBALS ####################################################################### # # PREPROCESSOR SECTION - Can be edited. Changes will be preserved. # ####################################################################### def jsonPreprocessor(text): return text, lambda i: i def get_preprocessor() -> PreprocessorFunc: return jsonPreprocessor ####################################################################### # # PARSER SECTION - Don't edit! CHANGES WILL BE OVERWRITTEN! # ####################################################################### class jsonGrammar(Grammar): r"""Parser for a json source file. """ element = Forward() value = Forward() source_hash__ = "06e67712cd6ccd3f0acd62f0cbe70ade" static_analysis_pending__ = [True] parser_initialization__ = ["upon instantiation"] resume_rules__ = {} COMMENT__ = r'\/\/.*' WHITESPACE__ = r'\s*' WSP_RE__ = mixin_comment(whitespace=WHITESPACE__, comment=COMMENT__) wsp__ = Whitespace(WSP_RE__) EOF = NegativeLookahead(RegExp('.')) EXP = Option(Series(Alternative(Token("E"), Token("e")), Option(Alternative(Token("+"), Token("-"))), RegExp('[0-9]+'))) FRAC = Option(Series(Token("."), RegExp('[0-9]+'))) INT = Alternative(Series(Option(Token("-")), RegExp('[0-9]')), RegExp('[1-9][0-9]+')) HEX = RegExp('[0-9a-fA-F]') ESCAPE = Alternative(RegExp('\\\\[/bnrt\\\\]'), Series(RegExp('\\\\u'), HEX, HEX, HEX, HEX)) CHARACTERS = ZeroOrMore(Alternative(RegExp('[^"\\\\]+'), ESCAPE)) number = Series(INT, FRAC, EXP, wsp__) string = Series(Token('"'), CHARACTERS, Token('"'), wsp__) array = Series(Series(Token("["), wsp__), Option(Series(value, ZeroOrMore(Series(Series(Token(","), wsp__), value)))), Series(Token("]"), wsp__)) member = Series(string, Series(Token(":"), wsp__), element) object = Series(Series(Token("{"), wsp__), Option(Series(member, ZeroOrMore(Series(Series(Token(","), wsp__), member)))), Series(Token("}"), wsp__)) value.set(Alternative(object, array, string, number, Series(Token("true"), wsp__), Series(Token("false"), wsp__), Series(Token("null"), wsp__))) element.set(Synonym(value)) json = Series(wsp__, element, EOF) root__ = json def get_grammar() -> jsonGrammar: """Returns a thread/process-exclusive jsonGrammar-singleton.""" try: grammar = GLOBALS.json_00000001_grammar_singleton except AttributeError: GLOBALS.json_00000001_grammar_singleton = jsonGrammar() if hasattr(get_grammar, 'python_src__'): GLOBALS.json_00000001_grammar_singleton.python_src__ = get_grammar.python_src__ grammar = GLOBALS.json_00000001_grammar_singleton return grammar ####################################################################### # # AST SECTION - Can be edited. Changes will be preserved. # ####################################################################### json_AST_transformation_table = { # AST Transformations for the json-grammar "<": flatten, "json": [], "element": [], "value": [], "object": [], "member": [], "array": [], "string": [], "number": [], "CHARACTERS": [], "ESCAPE": [], "HEX": [], "INT": [], "FRAC": [], "EXP": [], "EOF": [], "*": replace_by_single_child } def CreatejsonTransformer() -> TransformationFunc: """Creates a transformation function that does not share state with other threads or processes.""" return partial(traverse, processing_table=json_AST_transformation_table.copy()) def get_transformer() -> TransformationFunc: """Returns a thread/process-exclusive transformation function.""" try: transformer = GLOBALS.json_00000001_transformer_singleton except AttributeError: GLOBALS.json_00000001_transformer_singleton = CreatejsonTransformer() transformer = GLOBALS.json_00000001_transformer_singleton return transformer ####################################################################### # # COMPILER SECTION - Can be edited. Changes will be preserved. # ####################################################################### class jsonCompiler(Compiler): """Compiler for the abstract-syntax-tree of a json source file. """ def __init__(self): super(jsonCompiler, self).__init__() def _reset(self): super()._reset() # initialize your variables here, not in the constructor! def on_json(self, node): return self.fallback_compiler(node) # def on_element(self, node): # return node # def on_value(self, node): # return node # def on_object(self, node): # return node # def on_member(self, node): # return node # def on_array(self, node): # return node # def on_string(self, node): # return node # def on_number(self, node): # return node # def on_CHARACTERS(self, node): # return node # def on_ESCAPE(self, node): # return node # def on_HEX(self, node): # return node # def on_INT(self, node): # return node # def on_FRAC(self, node): # return node # def on_EXP(self, node): # return node # def on_EOF(self, node): # return node def get_compiler() -> jsonCompiler: """Returns a thread/process-exclusive jsonCompiler-singleton.""" try: compiler = GLOBALS.json_00000001_compiler_singleton except AttributeError: GLOBALS.json_00000001_compiler_singleton = jsonCompiler() compiler = GLOBALS.json_00000001_compiler_singleton return compiler ####################################################################### # # END OF DHPARSER-SECTIONS # ####################################################################### def compile_src(source, log_dir=''): """Compiles ``source`` and returns (result, errors, ast). """ with logging(log_dir): compiler = get_compiler() result_tuple = compile_source(source, get_preprocessor(), get_grammar(), get_transformer(), compiler) return result_tuple if __name__ == "__main__": # recompile grammar if needed grammar_path = os.path.abspath(__file__).replace('Compiler.py', '.ebnf') if os.path.exists(grammar_path): if not recompile_grammar(grammar_path, force=False, notify=lambda:print('recompiling ' + grammar_path)): error_file = os.path.basename(__file__).replace('Compiler.py', '_ebnf_ERRORS.txt') with open(error_file, encoding="utf-8") as f: print(f.read()) sys.exit(1) else: print('Could not check whether grammar requires recompiling, ' 'because grammar was not found at: ' + grammar_path) if len(sys.argv) > 1: # compile file file_name, log_dir = sys.argv[1], '' if file_name in ['-d', '--debug'] and len(sys.argv) > 2: file_name, log_dir = sys.argv[2], 'LOGS' result, errors, _ = compile_src(file_name, log_dir) if errors: cwd = os.getcwd() rel_path = file_name[len(cwd):] if file_name.startswith(cwd) else file_name for error in errors: print(rel_path + ':' + str(error)) sys.exit(1) else: print(result.as_xml() if isinstance(result, Node) else result) else: print("Usage: jsonCompiler.py [FILENAME]")