From bab63133135adadd654eb09c9d70675d15a127b9 Mon Sep 17 00:00:00 2001 From: Thomas Krijnen Date: Sun, 10 Jul 2022 21:51:25 +0200 Subject: [PATCH] Work on more readable ast for express schema parser --- .../ifcopenshell/express/bootstrap.py | 11 +- .../ifcopenshell/express/express_parser.py | 1657 ++++------------- .../ifcopenshell/express/nodes.py | 45 +- .../ifcopenshell/express/schema.py | 1 + 4 files changed, 375 insertions(+), 1339 deletions(-) diff --git a/src/ifcopenshell-python/ifcopenshell/express/bootstrap.py b/src/ifcopenshell-python/ifcopenshell/express/bootstrap.py index a109f7a6bf..444033fda0 100644 --- a/src/ifcopenshell-python/ifcopenshell/express/bootstrap.py +++ b/src/ifcopenshell-python/ifcopenshell/express/bootstrap.py @@ -161,7 +161,7 @@ statements = [] terminals = reduce(lambda x, y: x | y, (find_bytype(e, Terminal) for id, e in express)) keywords = list(filter(operator.attrgetter("is_keyword"), terminals)) negated_keywords = map(lambda s: "~%s" % s, keywords) -no_action = {"letter", "digit", "digits", "real_literal", "integer_literal"} +no_action = {"letter", "digit", "digits", "real_literal", "integer_literal", "string_literal", "simple_string_literal", "letter", "not_quote", "not_paren_star_quote_special"} while True: emitted_in_loop = set() @@ -199,8 +199,8 @@ for id in to_emit: stmt = "(%s)%s" % (stmt, action) statements.append("%s << %s" % (id, stmt)) -print( - """ +if __name__ == "__main__": + print(""" # This file is generated by IfcOpenShell ifcexpressparser bootstrap.py import os @@ -238,6 +238,5 @@ if __name__ == "__main__": mdl = importlib.import_module(output) mdl.Generator(m).emit() sys.stdout.write(m.schema.name) -""" - % ("\n ".join(statements)) -) +""" % ("\n ".join(statements)) + ) diff --git a/src/ifcopenshell-python/ifcopenshell/express/express_parser.py b/src/ifcopenshell-python/ifcopenshell/express/express_parser.py index f2638a639a..a41bf11c07 100644 --- a/src/ifcopenshell-python/ifcopenshell/express/express_parser.py +++ b/src/ifcopenshell-python/ifcopenshell/express/express_parser.py @@ -1,20 +1,3 @@ -# IfcOpenShell - IFC toolkit and geometry engine -# Copyright (C) 2021 Thomas Krijnen -# -# This file is part of IfcOpenShell. -# -# IfcOpenShell is free software: you can redistribute it and/or modify -# it under the terms of the GNU Lesser General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# IfcOpenShell is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public License -# along with IfcOpenShell. If not, see . # This file is generated by IfcOpenShell ifcexpressparser bootstrap.py @@ -28,21 +11,16 @@ import mapping from pyparsing import * from nodes import * - def parse(fn): cache_file = fn + ".cache.dat" if os.path.exists(cache_file) and os.path.getmtime(cache_file) >= os.path.getmtime(fn): with open(cache_file, "rb") as f: m = pickle.load(f) - else: + else: ABS = (CaselessKeyword("abs")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ABS"))("ABS") - ABSTRACT = (CaselessKeyword("abstract")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ABSTRACT"))( - "ABSTRACT" - ) + ABSTRACT = (CaselessKeyword("abstract")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ABSTRACT"))("ABSTRACT") ACOS = (CaselessKeyword("acos")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ACOS"))("ACOS") - AGGREGATE = (CaselessKeyword("aggregate")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="AGGREGATE"))( - "AGGREGATE" - ) + AGGREGATE = (CaselessKeyword("aggregate")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="AGGREGATE"))("AGGREGATE") ALIAS = (CaselessKeyword("alias")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ALIAS"))("ALIAS") AND = (CaselessKeyword("and")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="AND"))("AND") ANDOR = (CaselessKeyword("andor")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ANDOR"))("ANDOR") @@ -51,122 +29,64 @@ def parse(fn): ASIN = (CaselessKeyword("asin")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ASIN"))("ASIN") ATAN = (CaselessKeyword("atan")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ATAN"))("ATAN") BAG = (CaselessKeyword("bag")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="BAG"))("BAG") - BASED_ON = (CaselessKeyword("based_on")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="BASED_ON"))( - "BASED_ON" - ) + BASED_ON = (CaselessKeyword("based_on")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="BASED_ON"))("BASED_ON") BEGIN = (CaselessKeyword("begin")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="BEGIN"))("BEGIN") BINARY = (CaselessKeyword("binary")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="BINARY"))("BINARY") - BLENGTH = (CaselessKeyword("blength")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="BLENGTH"))( - "BLENGTH" - ) - BOOLEAN = (CaselessKeyword("boolean")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="BOOLEAN"))( - "BOOLEAN" - ) + BLENGTH = (CaselessKeyword("blength")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="BLENGTH"))("BLENGTH") + BOOLEAN = (CaselessKeyword("boolean")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="BOOLEAN"))("BOOLEAN") BY = (CaselessKeyword("by")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="BY"))("BY") CASE = (CaselessKeyword("case")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="CASE"))("CASE") - CONSTANT = (CaselessKeyword("constant")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="CONSTANT"))( - "CONSTANT" - ) - CONST_E = (CaselessKeyword("const_e")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="CONST_E"))( - "CONST_E" - ) + CONSTANT = (CaselessKeyword("constant")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="CONSTANT"))("CONSTANT") + CONST_E = (CaselessKeyword("const_e")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="CONST_E"))("CONST_E") COS = (CaselessKeyword("cos")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="COS"))("COS") DERIVE = (CaselessKeyword("derive")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="DERIVE"))("DERIVE") DIV = (CaselessKeyword("div")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="DIV"))("DIV") ELSE = (CaselessKeyword("else")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ELSE"))("ELSE") END = (CaselessKeyword("end")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END"))("END") - END_ALIAS = (CaselessKeyword("end_alias")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_ALIAS"))( - "END_ALIAS" - ) - END_CASE = (CaselessKeyword("end_case")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_CASE"))( - "END_CASE" - ) - END_CONSTANT = (CaselessKeyword("end_constant")).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="END_CONSTANT") - )("END_CONSTANT") - END_ENTITY = (CaselessKeyword("end_entity")).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="END_ENTITY") - )("END_ENTITY") - END_FUNCTION = (CaselessKeyword("end_function")).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="END_FUNCTION") - )("END_FUNCTION") + END_ALIAS = (CaselessKeyword("end_alias")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_ALIAS"))("END_ALIAS") + END_CASE = (CaselessKeyword("end_case")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_CASE"))("END_CASE") + END_CONSTANT = (CaselessKeyword("end_constant")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_CONSTANT"))("END_CONSTANT") + END_ENTITY = (CaselessKeyword("end_entity")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_ENTITY"))("END_ENTITY") + END_FUNCTION = (CaselessKeyword("end_function")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_FUNCTION"))("END_FUNCTION") END_IF = (CaselessKeyword("end_if")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_IF"))("END_IF") - END_LOCAL = (CaselessKeyword("end_local")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_LOCAL"))( - "END_LOCAL" - ) - END_PROCEDURE = (CaselessKeyword("end_procedure")).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="END_PROCEDURE") - )("END_PROCEDURE") - END_REPEAT = (CaselessKeyword("end_repeat")).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="END_REPEAT") - )("END_REPEAT") - END_RULE = (CaselessKeyword("end_rule")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_RULE"))( - "END_RULE" - ) - END_SCHEMA = (CaselessKeyword("end_schema")).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="END_SCHEMA") - )("END_SCHEMA") - END_SUBTYPE_CONSTRAINT = (CaselessKeyword("end_subtype_constraint")).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="END_SUBTYPE_CONSTRAINT") - )("END_SUBTYPE_CONSTRAINT") - END_TYPE = (CaselessKeyword("end_type")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_TYPE"))( - "END_TYPE" - ) + END_LOCAL = (CaselessKeyword("end_local")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_LOCAL"))("END_LOCAL") + END_PROCEDURE = (CaselessKeyword("end_procedure")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_PROCEDURE"))("END_PROCEDURE") + END_REPEAT = (CaselessKeyword("end_repeat")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_REPEAT"))("END_REPEAT") + END_RULE = (CaselessKeyword("end_rule")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_RULE"))("END_RULE") + END_SCHEMA = (CaselessKeyword("end_schema")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_SCHEMA"))("END_SCHEMA") + END_SUBTYPE_CONSTRAINT = (CaselessKeyword("end_subtype_constraint")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_SUBTYPE_CONSTRAINT"))("END_SUBTYPE_CONSTRAINT") + END_TYPE = (CaselessKeyword("end_type")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_TYPE"))("END_TYPE") ENTITY = (CaselessKeyword("entity")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ENTITY"))("ENTITY") - ENUMERATION = (CaselessKeyword("enumeration")).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="ENUMERATION") - )("ENUMERATION") + ENUMERATION = (CaselessKeyword("enumeration")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ENUMERATION"))("ENUMERATION") ESCAPE = (CaselessKeyword("escape")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ESCAPE"))("ESCAPE") EXISTS = (CaselessKeyword("exists")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="EXISTS"))("EXISTS") - EXTENSIBLE = (CaselessKeyword("extensible")).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="EXTENSIBLE") - )("EXTENSIBLE") + EXTENSIBLE = (CaselessKeyword("extensible")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="EXTENSIBLE"))("EXTENSIBLE") EXP = (CaselessKeyword("exp")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="EXP"))("EXP") FALSE = (CaselessKeyword("false")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="FALSE"))("FALSE") FIXED = (CaselessKeyword("fixed")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="FIXED"))("FIXED") FOR = (CaselessKeyword("for")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="FOR"))("FOR") FORMAT = (CaselessKeyword("format")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="FORMAT"))("FORMAT") FROM = (CaselessKeyword("from")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="FROM"))("FROM") - FUNCTION = (CaselessKeyword("function")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="FUNCTION"))( - "FUNCTION" - ) - GENERIC = (CaselessKeyword("generic")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="GENERIC"))( - "GENERIC" - ) - GENERIC_ENTITY = (CaselessKeyword("generic_entity")).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="GENERIC_ENTITY") - )("GENERIC_ENTITY") - HIBOUND = (CaselessKeyword("hibound")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="HIBOUND"))( - "HIBOUND" - ) - HIINDEX = (CaselessKeyword("hiindex")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="HIINDEX"))( - "HIINDEX" - ) + FUNCTION = (CaselessKeyword("function")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="FUNCTION"))("FUNCTION") + GENERIC = (CaselessKeyword("generic")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="GENERIC"))("GENERIC") + GENERIC_ENTITY = (CaselessKeyword("generic_entity")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="GENERIC_ENTITY"))("GENERIC_ENTITY") + HIBOUND = (CaselessKeyword("hibound")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="HIBOUND"))("HIBOUND") + HIINDEX = (CaselessKeyword("hiindex")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="HIINDEX"))("HIINDEX") IF = (CaselessKeyword("if")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="IF"))("IF") IN = (CaselessKeyword("in")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="IN"))("IN") INSERT = (CaselessKeyword("insert")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="INSERT"))("INSERT") - INTEGER = (CaselessKeyword("integer")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="INTEGER"))( - "INTEGER" - ) - INVERSE = (CaselessKeyword("inverse")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="INVERSE"))( - "INVERSE" - ) + INTEGER = (CaselessKeyword("integer")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="INTEGER"))("INTEGER") + INVERSE = (CaselessKeyword("inverse")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="INVERSE"))("INVERSE") LENGTH = (CaselessKeyword("length")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LENGTH"))("LENGTH") LIKE = (CaselessKeyword("like")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LIKE"))("LIKE") LIST = (CaselessKeyword("list")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LIST"))("LIST") - LOBOUND = (CaselessKeyword("lobound")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LOBOUND"))( - "LOBOUND" - ) + LOBOUND = (CaselessKeyword("lobound")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LOBOUND"))("LOBOUND") LOCAL = (CaselessKeyword("local")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LOCAL"))("LOCAL") LOG = (CaselessKeyword("log")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LOG"))("LOG") LOG10 = (CaselessKeyword("log10")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LOG10"))("LOG10") LOG2 = (CaselessKeyword("log2")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LOG2"))("LOG2") - LOGICAL = (CaselessKeyword("logical")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LOGICAL"))( - "LOGICAL" - ) - LOINDEX = (CaselessKeyword("loindex")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LOINDEX"))( - "LOINDEX" - ) + LOGICAL = (CaselessKeyword("logical")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LOGICAL"))("LOGICAL") + LOINDEX = (CaselessKeyword("loindex")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LOINDEX"))("LOINDEX") MOD = (CaselessKeyword("mod")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="MOD"))("MOD") NOT = (CaselessKeyword("not")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="NOT"))("NOT") NUMBER = (CaselessKeyword("number")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="NUMBER"))("NUMBER") @@ -174,31 +94,19 @@ def parse(fn): ODD = (CaselessKeyword("odd")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ODD"))("ODD") OF = (CaselessKeyword("of")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="OF"))("OF") ONEOF = (CaselessKeyword("oneof")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ONEOF"))("ONEOF") - OPTIONAL = (CaselessKeyword("optional")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="OPTIONAL"))( - "OPTIONAL" - ) + OPTIONAL = (CaselessKeyword("optional")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="OPTIONAL"))("OPTIONAL") OR = (CaselessKeyword("or")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="OR"))("OR") - OTHERWISE = (CaselessKeyword("otherwise")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="OTHERWISE"))( - "OTHERWISE" - ) + OTHERWISE = (CaselessKeyword("otherwise")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="OTHERWISE"))("OTHERWISE") PI = (CaselessKeyword("pi")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="PI"))("PI") - PROCEDURE = (CaselessKeyword("procedure")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="PROCEDURE"))( - "PROCEDURE" - ) + PROCEDURE = (CaselessKeyword("procedure")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="PROCEDURE"))("PROCEDURE") QUERY = (CaselessKeyword("query")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="QUERY"))("QUERY") REAL = (CaselessKeyword("real")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="REAL"))("REAL") - REFERENCE = (CaselessKeyword("reference")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="REFERENCE"))( - "REFERENCE" - ) + REFERENCE = (CaselessKeyword("reference")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="REFERENCE"))("REFERENCE") REMOVE = (CaselessKeyword("remove")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="REMOVE"))("REMOVE") - RENAMED = (CaselessKeyword("renamed")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="RENAMED"))( - "RENAMED" - ) + RENAMED = (CaselessKeyword("renamed")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="RENAMED"))("RENAMED") REPEAT = (CaselessKeyword("repeat")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="REPEAT"))("REPEAT") RETURN = (CaselessKeyword("return")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="RETURN"))("RETURN") - ROLESOF = (CaselessKeyword("rolesof")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ROLESOF"))( - "ROLESOF" - ) + ROLESOF = (CaselessKeyword("rolesof")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ROLESOF"))("ROLESOF") RULE = (CaselessKeyword("rule")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="RULE"))("RULE") SCHEMA = (CaselessKeyword("schema")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="SCHEMA"))("SCHEMA") SELECT = (CaselessKeyword("select")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="SELECT"))("SELECT") @@ -209,433 +117,84 @@ def parse(fn): SKIP = (CaselessKeyword("skip")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="SKIP"))("SKIP") SQRT = (CaselessKeyword("sqrt")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="SQRT"))("SQRT") STRING = (CaselessKeyword("string")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="STRING"))("STRING") - SUBTYPE = (CaselessKeyword("subtype")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="SUBTYPE"))( - "SUBTYPE" - ) - SUBTYPE_CONSTRAINT = (CaselessKeyword("subtype_constraint")).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="SUBTYPE_CONSTRAINT") - )("SUBTYPE_CONSTRAINT") - SUPERTYPE = (CaselessKeyword("supertype")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="SUPERTYPE"))( - "SUPERTYPE" - ) + SUBTYPE = (CaselessKeyword("subtype")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="SUBTYPE"))("SUBTYPE") + SUBTYPE_CONSTRAINT = (CaselessKeyword("subtype_constraint")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="SUBTYPE_CONSTRAINT"))("SUBTYPE_CONSTRAINT") + SUPERTYPE = (CaselessKeyword("supertype")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="SUPERTYPE"))("SUPERTYPE") TAN = (CaselessKeyword("tan")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="TAN"))("TAN") THEN = (CaselessKeyword("then")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="THEN"))("THEN") TO = (CaselessKeyword("to")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="TO"))("TO") - TOTAL_OVER = (CaselessKeyword("total_over")).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="TOTAL_OVER") - )("TOTAL_OVER") + TOTAL_OVER = (CaselessKeyword("total_over")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="TOTAL_OVER"))("TOTAL_OVER") TRUE = (CaselessKeyword("true")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="TRUE"))("TRUE") TYPE = (CaselessKeyword("type")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="TYPE"))("TYPE") TYPEOF = (CaselessKeyword("typeof")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="TYPEOF"))("TYPEOF") UNIQUE = (CaselessKeyword("unique")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="UNIQUE"))("UNIQUE") - UNKNOWN = (CaselessKeyword("unknown")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="UNKNOWN"))( - "UNKNOWN" - ) + UNKNOWN = (CaselessKeyword("unknown")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="UNKNOWN"))("UNKNOWN") UNTIL = (CaselessKeyword("until")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="UNTIL"))("UNTIL") USE = (CaselessKeyword("use")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="USE"))("USE") USEDIN = (CaselessKeyword("usedin")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="USEDIN"))("USEDIN") VALUE = (CaselessKeyword("value")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="VALUE"))("VALUE") - VALUE_IN = (CaselessKeyword("value_in")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="VALUE_IN"))( - "VALUE_IN" - ) - VALUE_UNIQUE = (CaselessKeyword("value_unique")).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="VALUE_UNIQUE") - )("VALUE_UNIQUE") + VALUE_IN = (CaselessKeyword("value_in")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="VALUE_IN"))("VALUE_IN") + VALUE_UNIQUE = (CaselessKeyword("value_unique")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="VALUE_UNIQUE"))("VALUE_UNIQUE") VAR = (CaselessKeyword("var")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="VAR"))("VAR") WHERE = (CaselessKeyword("where")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="WHERE"))("WHERE") WHILE = (CaselessKeyword("while")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="WHILE"))("WHILE") WITH = (CaselessKeyword("with")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="WITH"))("WITH") XOR = (CaselessKeyword("xor")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="XOR"))("XOR") - bit = ((CaselessLiteral("0") | CaselessLiteral("1"))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="bit") - )("bit") - digit = ( - ( - CaselessLiteral("0") - | CaselessLiteral("1") - | CaselessLiteral("2") - | CaselessLiteral("3") - | CaselessLiteral("4") - | CaselessLiteral("5") - | CaselessLiteral("6") - | CaselessLiteral("7") - | CaselessLiteral("8") - | CaselessLiteral("9") - ) - )("digit") + bit = ((CaselessLiteral("0") | CaselessLiteral("1"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="bit"))("bit") + digit = ((CaselessLiteral("0") | CaselessLiteral("1") | CaselessLiteral("2") | CaselessLiteral("3") | CaselessLiteral("4") | CaselessLiteral("5") | CaselessLiteral("6") | CaselessLiteral("7") | CaselessLiteral("8") | CaselessLiteral("9")))("digit") digits = ((digit + ZeroOrMore(digit)))("digits") - hex_digit = ( - ( - digit - | CaselessLiteral("a") - | CaselessLiteral("b") - | CaselessLiteral("c") - | CaselessLiteral("d") - | CaselessLiteral("e") - | CaselessLiteral("f") - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="hex_digit"))("hex_digit") - letter = ( - ( - CaselessLiteral("a") - | CaselessLiteral("b") - | CaselessLiteral("c") - | CaselessLiteral("d") - | CaselessLiteral("e") - | CaselessLiteral("f") - | CaselessLiteral("g") - | CaselessLiteral("h") - | CaselessLiteral("i") - | CaselessLiteral("j") - | CaselessLiteral("k") - | CaselessLiteral("l") - | CaselessLiteral("m") - | CaselessLiteral("n") - | CaselessLiteral("o") - | CaselessLiteral("p") - | CaselessLiteral("q") - | CaselessLiteral("r") - | CaselessLiteral("s") - | CaselessLiteral("t") - | CaselessLiteral("u") - | CaselessLiteral("v") - | CaselessLiteral("w") - | CaselessLiteral("x") - | CaselessLiteral("y") - | CaselessLiteral("z") - ) - )("letter") - not_paren_star_quote_special = ( - ( - CaselessLiteral("!") - | CaselessLiteral("#") - | CaselessLiteral("$") - | CaselessLiteral("%") - | CaselessLiteral("&") - | CaselessLiteral("+") - | CaselessLiteral(",") - | CaselessLiteral("-") - | CaselessLiteral(".") - | CaselessLiteral("/") - | CaselessLiteral(":") - | CaselessLiteral(";") - | CaselessLiteral("<") - | CaselessLiteral("=") - | CaselessLiteral(">") - | CaselessLiteral("?") - | CaselessLiteral("@") - | CaselessLiteral("[") - | CaselessLiteral("\\") - | CaselessLiteral("]") - | CaselessLiteral("^") - | CaselessLiteral("_") - | CaselessLiteral("{") - | CaselessLiteral("|") - | CaselessLiteral("}") - | CaselessLiteral("~") - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="not_paren_star_quote_special"))( - "not_paren_star_quote_special" - ) - not_paren_star_special = ((not_paren_star_quote_special | CaselessLiteral('""'))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="not_paren_star_special") - )("not_paren_star_special") - not_quote = ( - ( - not_paren_star_quote_special - | letter - | digit - | CaselessLiteral("(") - | CaselessLiteral(")") - | CaselessLiteral("*") - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="not_quote"))("not_quote") + hex_digit = ((digit | CaselessLiteral("a") | CaselessLiteral("b") | CaselessLiteral("c") | CaselessLiteral("d") | CaselessLiteral("e") | CaselessLiteral("f"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="hex_digit"))("hex_digit") + letter = ((CaselessLiteral("a") | CaselessLiteral("b") | CaselessLiteral("c") | CaselessLiteral("d") | CaselessLiteral("e") | CaselessLiteral("f") | CaselessLiteral("g") | CaselessLiteral("h") | CaselessLiteral("i") | CaselessLiteral("j") | CaselessLiteral("k") | CaselessLiteral("l") | CaselessLiteral("m") | CaselessLiteral("n") | CaselessLiteral("o") | CaselessLiteral("p") | CaselessLiteral("q") | CaselessLiteral("r") | CaselessLiteral("s") | CaselessLiteral("t") | CaselessLiteral("u") | CaselessLiteral("v") | CaselessLiteral("w") | CaselessLiteral("x") | CaselessLiteral("y") | CaselessLiteral("z")))("letter") + not_paren_star_quote_special = ((CaselessLiteral("!") | CaselessLiteral("#") | CaselessLiteral("$") | CaselessLiteral("%") | CaselessLiteral("&") | CaselessLiteral("+") | CaselessLiteral(",") | CaselessLiteral("-") | CaselessLiteral(".") | CaselessLiteral("/") | CaselessLiteral(":") | CaselessLiteral(";") | CaselessLiteral("<") | CaselessLiteral("=") | CaselessLiteral(">") | CaselessLiteral("?") | CaselessLiteral("@") | CaselessLiteral("[") | CaselessLiteral("\\") | CaselessLiteral("]") | CaselessLiteral("^") | CaselessLiteral("_") | CaselessLiteral("{") | CaselessLiteral("|") | CaselessLiteral("}") | CaselessLiteral("~")))("not_paren_star_quote_special") + not_paren_star_special = ((not_paren_star_quote_special | CaselessLiteral("\"\""))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="not_paren_star_special"))("not_paren_star_special") + not_quote = ((not_paren_star_quote_special | letter | digit | CaselessLiteral("(") | CaselessLiteral(")") | CaselessLiteral("*")))("not_quote") octet = ((hex_digit + hex_digit)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="octet"))("octet") - special = ( - ( - not_paren_star_quote_special - | CaselessLiteral("(") - | CaselessLiteral(")") - | CaselessLiteral("*") - | CaselessLiteral('""') - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="special"))("special") - binary_literal = ((CaselessLiteral("%") + bit + ZeroOrMore(bit))).setParseAction( - lambda s, loc, t: ListNode(s, loc, t, rule="binary_literal") - )("binary_literal") + special = ((not_paren_star_quote_special | CaselessLiteral("(") | CaselessLiteral(")") | CaselessLiteral("*") | CaselessLiteral("\"\""))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="special"))("special") + binary_literal = ((CaselessLiteral("%") + bit + ZeroOrMore(bit))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="binary_literal"))("binary_literal") integer_literal = (digits)("integer_literal") - simple_id = ( - ~CaselessKeyword("supertype") - + ~CaselessKeyword("generic") - + ~CaselessKeyword("true") - + ~CaselessKeyword("rolesof") - + ~CaselessKeyword("local") - + ~CaselessKeyword("enumeration") - + ~CaselessKeyword("in") - + ~CaselessKeyword("subtype_constraint") - + ~CaselessKeyword("while") - + ~CaselessKeyword("var") - + ~CaselessKeyword("unique") - + ~CaselessKeyword("type") - + ~CaselessKeyword("format") - + ~CaselessKeyword("log2") - + ~CaselessKeyword("set") - + ~CaselessKeyword("string") - + ~CaselessKeyword("exp") - + ~CaselessKeyword("inverse") - + ~CaselessKeyword("sizeof") - + ~CaselessKeyword("function") - + ~CaselessKeyword("of") - + ~CaselessKeyword("value_in") - + ~CaselessKeyword("procedure") - + ~CaselessKeyword("subtype") - + ~CaselessKeyword("for") - + ~CaselessKeyword("const_e") - + ~CaselessKeyword("acos") - + ~CaselessKeyword("asin") - + ~CaselessKeyword("return") - + ~CaselessKeyword("optional") - + ~CaselessKeyword("usedin") - + ~CaselessKeyword("log") - + ~CaselessKeyword("not") - + ~CaselessKeyword("from") - + ~CaselessKeyword("and") - + ~CaselessKeyword("pi") - + ~CaselessKeyword("begin") - + ~CaselessKeyword("end") - + ~CaselessKeyword("end_procedure") - + ~CaselessKeyword("loindex") - + ~CaselessKeyword("bag") - + ~CaselessKeyword("log10") - + ~CaselessKeyword("aggregate") - + ~CaselessKeyword("number") - + ~CaselessKeyword("by") - + ~CaselessKeyword("until") - + ~CaselessKeyword("array") - + ~CaselessKeyword("renamed") - + ~CaselessKeyword("entity") - + ~CaselessKeyword("andor") - + ~CaselessKeyword("mod") - + ~CaselessKeyword("end_function") - + ~CaselessKeyword("cos") - + ~CaselessKeyword("sin") - + ~CaselessKeyword("list") - + ~CaselessKeyword("as") - + ~CaselessKeyword("binary") - + ~CaselessKeyword("escape") - + ~CaselessKeyword("value_unique") - + ~CaselessKeyword("sqrt") - + ~CaselessKeyword("real") - + ~CaselessKeyword("atan") - + ~CaselessKeyword("with") - + ~CaselessKeyword("unknown") - + ~CaselessKeyword("boolean") - + ~CaselessKeyword("abs") - + ~CaselessKeyword("fixed") - + ~CaselessKeyword("use") - + ~CaselessKeyword("repeat") - + ~CaselessKeyword("self") - + ~CaselessKeyword("value") - + ~CaselessKeyword("insert") - + ~CaselessKeyword("integer") - + ~CaselessKeyword("rule") - + ~CaselessKeyword("total_over") - + ~CaselessKeyword("tan") - + ~CaselessKeyword("case") - + ~CaselessKeyword("else") - + ~CaselessKeyword("schema") - + ~CaselessKeyword("derive") - + ~CaselessKeyword("remove") - + ~CaselessKeyword("like") - + ~CaselessKeyword("select") - + ~CaselessKeyword("alias") - + ~CaselessKeyword("abstract") - + ~CaselessKeyword("blength") - + ~CaselessKeyword("end_if") - + ~CaselessKeyword("xor") - + ~CaselessKeyword("skip") - + ~CaselessKeyword("generic_entity") - + ~CaselessKeyword("based_on") - + ~CaselessKeyword("exists") - + ~CaselessKeyword("or") - + ~CaselessKeyword("odd") - + ~CaselessKeyword("length") - + ~CaselessKeyword("constant") - + ~CaselessKeyword("end_type") - + ~CaselessKeyword("false") - + ~CaselessKeyword("end_subtype_constraint") - + ~CaselessKeyword("then") - + ~CaselessKeyword("end_repeat") - + ~CaselessKeyword("nvl") - + ~CaselessKeyword("where") - + ~CaselessKeyword("hibound") - + ~CaselessKeyword("lobound") - + ~CaselessKeyword("end_rule") - + ~CaselessKeyword("div") - + ~CaselessKeyword("query") - + ~CaselessKeyword("reference") - + ~CaselessKeyword("end_alias") - + ~CaselessKeyword("end_local") - + ~CaselessKeyword("logical") - + ~CaselessKeyword("if") - + ~CaselessKeyword("hiindex") - + ~CaselessKeyword("end_entity") - + ~CaselessKeyword("extensible") - + ~CaselessKeyword("end_case") - + ~CaselessKeyword("oneof") - + ~CaselessKeyword("otherwise") - + ~CaselessKeyword("end_constant") - + ~CaselessKeyword("end_schema") - + ~CaselessKeyword("to") - + ~CaselessKeyword("typeof") - + originalTextFor(Combine((letter + ZeroOrMore((letter | digit | CaselessLiteral("_"))))))("simple_id") - ) - simple_string_literal = ( - ( - CaselessLiteral("'") - + ZeroOrMore(((CaselessLiteral("'") + CaselessLiteral("'")) | not_quote)) - + CaselessLiteral("'") - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="simple_string_literal"))("simple_string_literal") + simple_id = ~CaselessKeyword("abstract") + ~CaselessKeyword("reference") + ~CaselessKeyword("pi") + ~CaselessKeyword("andor") + ~CaselessKeyword("loindex") + ~CaselessKeyword("aggregate") + ~CaselessKeyword("self") + ~CaselessKeyword("length") + ~CaselessKeyword("optional") + ~CaselessKeyword("for") + ~CaselessKeyword("end") + ~CaselessKeyword("local") + ~CaselessKeyword("true") + ~CaselessKeyword("logical") + ~CaselessKeyword("constant") + ~CaselessKeyword("nvl") + ~CaselessKeyword("bag") + ~CaselessKeyword("repeat") + ~CaselessKeyword("boolean") + ~CaselessKeyword("otherwise") + ~CaselessKeyword("type") + ~CaselessKeyword("typeof") + ~CaselessKeyword("alias") + ~CaselessKeyword("in") + ~CaselessKeyword("mod") + ~CaselessKeyword("escape") + ~CaselessKeyword("or") + ~CaselessKeyword("of") + ~CaselessKeyword("like") + ~CaselessKeyword("value_unique") + ~CaselessKeyword("tan") + ~CaselessKeyword("oneof") + ~CaselessKeyword("log") + ~CaselessKeyword("schema") + ~CaselessKeyword("fixed") + ~CaselessKeyword("by") + ~CaselessKeyword("integer") + ~CaselessKeyword("div") + ~CaselessKeyword("log10") + ~CaselessKeyword("not") + ~CaselessKeyword("skip") + ~CaselessKeyword("odd") + ~CaselessKeyword("return") + ~CaselessKeyword("end_subtype_constraint") + ~CaselessKeyword("end_alias") + ~CaselessKeyword("remove") + ~CaselessKeyword("unknown") + ~CaselessKeyword("end_repeat") + ~CaselessKeyword("enumeration") + ~CaselessKeyword("query") + ~CaselessKeyword("function") + ~CaselessKeyword("list") + ~CaselessKeyword("end_local") + ~CaselessKeyword("cos") + ~CaselessKeyword("atan") + ~CaselessKeyword("hibound") + ~CaselessKeyword("rolesof") + ~CaselessKeyword("end_function") + ~CaselessKeyword("abs") + ~CaselessKeyword("renamed") + ~CaselessKeyword("select") + ~CaselessKeyword("end_if") + ~CaselessKeyword("case") + ~CaselessKeyword("sizeof") + ~CaselessKeyword("var") + ~CaselessKeyword("end_case") + ~CaselessKeyword("acos") + ~CaselessKeyword("supertype") + ~CaselessKeyword("then") + ~CaselessKeyword("inverse") + ~CaselessKeyword("hiindex") + ~CaselessKeyword("false") + ~CaselessKeyword("generic") + ~CaselessKeyword("as") + ~CaselessKeyword("use") + ~CaselessKeyword("end_entity") + ~CaselessKeyword("rule") + ~CaselessKeyword("derive") + ~CaselessKeyword("set") + ~CaselessKeyword("subtype") + ~CaselessKeyword("unique") + ~CaselessKeyword("subtype_constraint") + ~CaselessKeyword("where") + ~CaselessKeyword("until") + ~CaselessKeyword("usedin") + ~CaselessKeyword("value") + ~CaselessKeyword("array") + ~CaselessKeyword("sqrt") + ~CaselessKeyword("value_in") + ~CaselessKeyword("to") + ~CaselessKeyword("xor") + ~CaselessKeyword("sin") + ~CaselessKeyword("while") + ~CaselessKeyword("with") + ~CaselessKeyword("string") + ~CaselessKeyword("total_over") + ~CaselessKeyword("binary") + ~CaselessKeyword("exp") + ~CaselessKeyword("and") + ~CaselessKeyword("number") + ~CaselessKeyword("generic_entity") + ~CaselessKeyword("const_e") + ~CaselessKeyword("end_type") + ~CaselessKeyword("log2") + ~CaselessKeyword("lobound") + ~CaselessKeyword("end_procedure") + ~CaselessKeyword("end_schema") + ~CaselessKeyword("end_constant") + ~CaselessKeyword("procedure") + ~CaselessKeyword("else") + ~CaselessKeyword("end_rule") + ~CaselessKeyword("if") + ~CaselessKeyword("based_on") + ~CaselessKeyword("exists") + ~CaselessKeyword("asin") + ~CaselessKeyword("blength") + ~CaselessKeyword("entity") + ~CaselessKeyword("from") + ~CaselessKeyword("format") + ~CaselessKeyword("insert") + ~CaselessKeyword("begin") + ~CaselessKeyword("extensible") + ~CaselessKeyword("real") + originalTextFor(Combine((letter + ZeroOrMore((letter | digit | CaselessLiteral("_"))))))("simple_id") + simple_string_literal = ((CaselessLiteral("'") + ZeroOrMore(((CaselessLiteral("'") + CaselessLiteral("'")) | not_quote)) + CaselessLiteral("'")))("simple_string_literal") abstract_entity_declaration = (ABSTRACT)("abstract_entity_declaration") - abstract_supertype = ((ABSTRACT + SUPERTYPE + CaselessLiteral(";"))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="abstract_supertype") - )("abstract_supertype") - add_like_op = ((CaselessLiteral("+") | CaselessLiteral("-") | OR | XOR)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="add_like_op") - )("add_like_op") + abstract_supertype = ((ABSTRACT + SUPERTYPE + CaselessLiteral(";"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="abstract_supertype"))("abstract_supertype") + add_like_op = ((CaselessLiteral("+") | CaselessLiteral("-") | OR | XOR)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="add_like_op"))("add_like_op") attribute_id = (simple_id)("attribute_id") boolean_type = (BOOLEAN)("boolean_type") - built_in_constant = ((CONST_E | PI | SELF | CaselessLiteral("?"))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="built_in_constant") - )("built_in_constant") - built_in_function = ( - ( - ABS - | ACOS - | ASIN - | ATAN - | BLENGTH - | COS - | EXISTS - | EXP - | FORMAT - | HIBOUND - | HIINDEX - | LENGTH - | LOBOUND - | LOINDEX - | LOG - | LOG2 - | LOG10 - | NVL - | ODD - | ROLESOF - | SIN - | SIZEOF - | SQRT - | TAN - | TYPEOF - | USEDIN - | VALUE - | VALUE_IN - | VALUE_UNIQUE - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="built_in_function"))("built_in_function") - built_in_procedure = ((INSERT | REMOVE)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="built_in_procedure") - )("built_in_procedure") + built_in_constant = ((CONST_E | PI | SELF | CaselessLiteral("?"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="built_in_constant"))("built_in_constant") + built_in_function = ((ABS | ACOS | ASIN | ATAN | BLENGTH | COS | EXISTS | EXP | FORMAT | HIBOUND | HIINDEX | LENGTH | LOBOUND | LOINDEX | LOG | LOG2 | LOG10 | NVL | ODD | ROLESOF | SIN | SIZEOF | SQRT | TAN | TYPEOF | USEDIN | VALUE | VALUE_IN | VALUE_UNIQUE)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="built_in_function"))("built_in_function") + built_in_procedure = ((INSERT | REMOVE)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="built_in_procedure"))("built_in_procedure") constant_id = (simple_id)("constant_id") entity_id = (simple_id)("entity_id") enumeration_id = (simple_id)("enumeration_id") - enumeration_items = ( - ( - CaselessLiteral("(") - + enumeration_id - + ZeroOrMore((CaselessLiteral(",") + enumeration_id)) - + CaselessLiteral(")") - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="enumeration_items"))("enumeration_items") - escape_stmt = ((ESCAPE + CaselessLiteral(";"))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="escape_stmt") - )("escape_stmt") + enumeration_items = ((CaselessLiteral("(") + enumeration_id + ZeroOrMore((CaselessLiteral(",") + enumeration_id)) + CaselessLiteral(")"))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="enumeration_items"))("enumeration_items") + escape_stmt = ((ESCAPE + CaselessLiteral(";"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="escape_stmt"))("escape_stmt") function_id = (simple_id)("function_id") integer_type = (INTEGER)("integer_type") - interval_op = ((CaselessLiteral("<=") | CaselessLiteral("<"))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="interval_op") - )("interval_op") - logical_literal = ((FALSE | TRUE | UNKNOWN)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="logical_literal") - )("logical_literal") + interval_op = ((CaselessLiteral("<=") | CaselessLiteral("<"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="interval_op"))("interval_op") + logical_literal = ((FALSE | TRUE | UNKNOWN)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="logical_literal"))("logical_literal") logical_type = (LOGICAL)("logical_type") - multiplication_like_op = ( - (CaselessLiteral("*") | CaselessLiteral("/") | DIV | MOD | AND | CaselessLiteral("||")) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="multiplication_like_op"))("multiplication_like_op") - null_stmt = (CaselessLiteral(";")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="null_stmt"))( - "null_stmt" - ) + multiplication_like_op = ((CaselessLiteral("*") | CaselessLiteral("/") | DIV | MOD | AND | CaselessLiteral("||"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="multiplication_like_op"))("multiplication_like_op") + null_stmt = (CaselessLiteral(";")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="null_stmt"))("null_stmt") number_type = (NUMBER)("number_type") parameter_id = (simple_id)("parameter_id") procedure_id = (simple_id)("procedure_id") - rel_op = ( - ( - CaselessLiteral("<=") - | CaselessLiteral(">=") - | CaselessLiteral("<>") - | CaselessLiteral("=") - | CaselessLiteral(":<>:") - | CaselessLiteral(":=:") - | CaselessLiteral("<") - | CaselessLiteral(">") - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="rel_op"))("rel_op") - rel_op_extended = ((rel_op | IN | LIKE)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="rel_op_extended") - )("rel_op_extended") + rel_op = ((CaselessLiteral("<=") | CaselessLiteral(">=") | CaselessLiteral("<>") | CaselessLiteral("=") | CaselessLiteral(":<>:") | CaselessLiteral(":=:") | CaselessLiteral("<") | CaselessLiteral(">"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="rel_op"))("rel_op") + rel_op_extended = ((rel_op | IN | LIKE)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="rel_op_extended"))("rel_op_extended") rule_id = (simple_id)("rule_id") rule_label_id = (simple_id)("rule_label_id") schema_id = (simple_id)("schema_id") - sign = ((CaselessLiteral("+") | CaselessLiteral("-"))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="sign") - )("sign") - skip_stmt = ((SKIP + CaselessLiteral(";"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="skip_stmt"))( - "skip_stmt" - ) + sign = ((CaselessLiteral("+") | CaselessLiteral("-"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="sign"))("sign") + skip_stmt = ((SKIP + CaselessLiteral(";"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="skip_stmt"))("skip_stmt") subtype_constraint_id = (simple_id)("subtype_constraint_id") type_id = (simple_id)("type_id") type_label_id = (simple_id)("type_label_id") - unary_op = ((CaselessLiteral("+") | CaselessLiteral("-") | NOT)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="unary_op") - )("unary_op") + unary_op = ((CaselessLiteral("+") | CaselessLiteral("-") | NOT)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="unary_op"))("unary_op") variable_id = (simple_id)("variable_id") - encoded_character = ((octet + octet + octet + octet)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="encoded_character") - )("encoded_character") - not_paren_star = ((letter | digit | not_paren_star_special)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="not_paren_star") - )("not_paren_star") - not_rparen_star = ((not_paren_star | CaselessLiteral("("))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="not_rparen_star") - )("not_rparen_star") - not_rparen_star_then_rparen = ( - (not_rparen_star + ZeroOrMore(not_rparen_star) + CaselessLiteral(")") + ZeroOrMore(CaselessLiteral(")"))) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="not_rparen_star_then_rparen"))( - "not_rparen_star_then_rparen" - ) - encoded_string_literal = ( - (CaselessLiteral('"') + encoded_character + ZeroOrMore(encoded_character) + CaselessLiteral('"')) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="encoded_string_literal"))("encoded_string_literal") - real_literal = ( - ( - ( - digits - + CaselessLiteral(".") - + Optional(digits) - + Optional((CaselessLiteral("e") + Optional(sign) + digits)) - ) - | integer_literal - ) - )("real_literal") + encoded_character = ((octet + octet + octet + octet)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="encoded_character"))("encoded_character") + not_paren_star = ((letter | digit | not_paren_star_special)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="not_paren_star"))("not_paren_star") + not_rparen_star = ((not_paren_star | CaselessLiteral("("))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="not_rparen_star"))("not_rparen_star") + not_rparen_star_then_rparen = ((not_rparen_star + ZeroOrMore(not_rparen_star) + CaselessLiteral(")") + ZeroOrMore(CaselessLiteral(")")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="not_rparen_star_then_rparen"))("not_rparen_star_then_rparen") + encoded_string_literal = ((CaselessLiteral("\"") + encoded_character + ZeroOrMore(encoded_character) + CaselessLiteral("\""))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="encoded_string_literal"))("encoded_string_literal") + real_literal = (((digits + CaselessLiteral(".") + Optional(digits) + Optional((CaselessLiteral("e") + Optional(sign) + digits))) | integer_literal))("real_literal") attribute_ref = (attribute_id)("attribute_ref") constant_ref = (constant_id)("constant_ref") entity_ref = (entity_id)("entity_ref") @@ -650,830 +209,265 @@ def parse(fn): type_label_ref = (type_label_id)("type_label_ref") type_ref = (type_id)("type_ref") variable_ref = (variable_id)("variable_ref") - attribute_qualifier = ((CaselessLiteral(".") + attribute_ref)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="attribute_qualifier") - )("attribute_qualifier") - constant_factor = ((built_in_constant | constant_ref)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="constant_factor") - )("constant_factor") - enumeration_extension = ((BASED_ON + type_ref + Optional((WITH + enumeration_items)))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="enumeration_extension") - )("enumeration_extension") - enumeration_reference = ((Optional((type_ref + CaselessLiteral("."))) + enumeration_ref)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="enumeration_reference") - )("enumeration_reference") - enumeration_type = ( - (Optional(EXTENSIBLE) + ENUMERATION + Optional(((OF + enumeration_items) | enumeration_extension))) - ).setParseAction(EnumerationType)("enumeration_type") - general_ref = ((parameter_ref | variable_ref)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="general_ref") - )("general_ref") - group_qualifier = ((CaselessLiteral("\\") + entity_ref)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="group_qualifier") - )("group_qualifier") + attribute_qualifier = ((CaselessLiteral(".") + attribute_ref)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="attribute_qualifier"))("attribute_qualifier") + constant_factor = ((built_in_constant | constant_ref)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="constant_factor"))("constant_factor") + enumeration_extension = ((BASED_ON + type_ref + Optional((WITH + enumeration_items)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="enumeration_extension"))("enumeration_extension") + enumeration_reference = ((Optional((type_ref + CaselessLiteral("."))) + enumeration_ref)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="enumeration_reference"))("enumeration_reference") + enumeration_type = ((Optional(EXTENSIBLE) + ENUMERATION + Optional(((OF + enumeration_items) | enumeration_extension)))).setParseAction(EnumerationType)("enumeration_type") + general_ref = ((parameter_ref | variable_ref)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_ref"))("general_ref") + group_qualifier = ((CaselessLiteral("\\") + entity_ref)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="group_qualifier"))("group_qualifier") named_types = ((entity_ref | type_ref)).setParseAction(NamedType)("named_types") - named_type_or_rename = ((named_types + Optional((AS + (entity_id | type_id))))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="named_type_or_rename") - )("named_type_or_rename") + named_type_or_rename = ((named_types + Optional((AS + (entity_id | type_id))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="named_type_or_rename"))("named_type_or_rename") population = (entity_ref)("population") - qualified_attribute = ((SELF + group_qualifier + attribute_qualifier)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="qualified_attribute") - )("qualified_attribute") - redeclared_attribute = ((qualified_attribute + Optional((RENAMED + attribute_id)))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="redeclared_attribute") - )("redeclared_attribute") - referenced_attribute = ((attribute_ref | qualified_attribute)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="referenced_attribute") - )("referenced_attribute") - rename_id = ((constant_id | entity_id | function_id | procedure_id | type_id)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="rename_id") - )("rename_id") - resource_ref = ((constant_ref | entity_ref | function_ref | procedure_ref | type_ref)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="resource_ref") - )("resource_ref") - rule_head = ( - ( - RULE - + rule_id - + FOR - + CaselessLiteral("(") - + entity_ref - + ZeroOrMore((CaselessLiteral(",") + entity_ref)) - + CaselessLiteral(")") - + CaselessLiteral(";") - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="rule_head"))("rule_head") - select_list = ( - ( - CaselessLiteral("(") - + named_types - + ZeroOrMore((CaselessLiteral(",") + named_types)) - + CaselessLiteral(")") - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="select_list"))("select_list") - string_literal = ((simple_string_literal | encoded_string_literal)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="string_literal") - )("string_literal") - subtype_constraint_head = ( - (SUBTYPE_CONSTRAINT + subtype_constraint_id + FOR + entity_ref + CaselessLiteral(";")) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint_head"))("subtype_constraint_head") - subtype_declaration = ( - ( - SUBTYPE - + OF - + CaselessLiteral("(") - + entity_ref - + ZeroOrMore((CaselessLiteral(",") + entity_ref)) - + CaselessLiteral(")") - ) - ).setParseAction(SubTypeExpression)("subtype_declaration") - total_over = ( - ( - TOTAL_OVER - + CaselessLiteral("(") - + entity_ref - + ZeroOrMore((CaselessLiteral(",") + entity_ref)) - + CaselessLiteral(")") - + CaselessLiteral(";") - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="total_over"))("total_over") - type_label = ((type_label_id | type_label_ref)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="type_label") - )("type_label") - unique_rule = ( - ( - Optional((rule_label_id + CaselessLiteral(":"))) - + referenced_attribute - + ZeroOrMore((CaselessLiteral(",") + referenced_attribute)) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="unique_rule"))("unique_rule") - use_clause = ( - ( - USE - + FROM - + schema_ref - + Optional( - ( - CaselessLiteral("(") - + named_type_or_rename - + ZeroOrMore((CaselessLiteral(",") + named_type_or_rename)) - + CaselessLiteral(")") - ) - ) - + CaselessLiteral(";") - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="use_clause"))("use_clause") - not_lparen_star = ((not_paren_star | CaselessLiteral(")"))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="not_lparen_star") - )("not_lparen_star") - remark_ref = ( - ( - attribute_ref - | constant_ref - | entity_ref - | enumeration_ref - | function_ref - | parameter_ref - | procedure_ref - | rule_label_ref - | rule_ref - | schema_ref - | subtype_constraint_ref - | type_label_ref - | type_ref - | variable_ref - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="remark_ref"))("remark_ref") - attribute_decl = ((redeclared_attribute | attribute_id)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="attribute_decl") - )("attribute_decl") - generic_entity_type = ((GENERIC_ENTITY + Optional((CaselessLiteral(":") + type_label)))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="generic_entity_type") - )("generic_entity_type") - generic_type = ((GENERIC + Optional((CaselessLiteral(":") + type_label)))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="generic_type") - )("generic_type") - literal = ((binary_literal | logical_literal | real_literal | string_literal)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="literal") - )("literal") - resource_or_rename = ((resource_ref + Optional((AS + rename_id)))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="resource_or_rename") - )("resource_or_rename") + qualified_attribute = ((SELF + group_qualifier + attribute_qualifier)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="qualified_attribute"))("qualified_attribute") + redeclared_attribute = ((qualified_attribute + Optional((RENAMED + attribute_id)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="redeclared_attribute"))("redeclared_attribute") + referenced_attribute = ((attribute_ref | qualified_attribute)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="referenced_attribute"))("referenced_attribute") + rename_id = ((constant_id | entity_id | function_id | procedure_id | type_id)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="rename_id"))("rename_id") + resource_ref = ((constant_ref | entity_ref | function_ref | procedure_ref | type_ref)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="resource_ref"))("resource_ref") + rule_head = ((RULE + rule_id + FOR + CaselessLiteral("(") + entity_ref + ZeroOrMore((CaselessLiteral(",") + entity_ref)) + CaselessLiteral(")") + CaselessLiteral(";"))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="rule_head"))("rule_head") + select_list = ((CaselessLiteral("(") + named_types + ZeroOrMore((CaselessLiteral(",") + named_types)) + CaselessLiteral(")"))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="select_list"))("select_list") + string_literal = ((simple_string_literal | encoded_string_literal))("string_literal") + subtype_constraint_head = ((SUBTYPE_CONSTRAINT + subtype_constraint_id + FOR + entity_ref + CaselessLiteral(";"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint_head"))("subtype_constraint_head") + subtype_declaration = ((SUBTYPE + OF + CaselessLiteral("(") + entity_ref + ZeroOrMore((CaselessLiteral(",") + entity_ref)) + CaselessLiteral(")"))).setParseAction(SubTypeExpression)("subtype_declaration") + total_over = ((TOTAL_OVER + CaselessLiteral("(") + entity_ref + ZeroOrMore((CaselessLiteral(",") + entity_ref)) + CaselessLiteral(")") + CaselessLiteral(";"))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="total_over"))("total_over") + type_label = ((type_label_id | type_label_ref)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="type_label"))("type_label") + unique_rule = ((Optional((rule_label_id + CaselessLiteral(":"))) + referenced_attribute + ZeroOrMore((CaselessLiteral(",") + referenced_attribute)))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="unique_rule"))("unique_rule") + use_clause = ((USE + FROM + schema_ref + Optional((CaselessLiteral("(") + named_type_or_rename + ZeroOrMore((CaselessLiteral(",") + named_type_or_rename)) + CaselessLiteral(")"))) + CaselessLiteral(";"))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="use_clause"))("use_clause") + not_lparen_star = ((not_paren_star | CaselessLiteral(")"))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="not_lparen_star"))("not_lparen_star") + remark_ref = ((attribute_ref | constant_ref | entity_ref | enumeration_ref | function_ref | parameter_ref | procedure_ref | rule_label_ref | rule_ref | schema_ref | subtype_constraint_ref | type_label_ref | type_ref | variable_ref)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="remark_ref"))("remark_ref") + attribute_decl = ((redeclared_attribute | attribute_id)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="attribute_decl"))("attribute_decl") + generic_entity_type = ((GENERIC_ENTITY + Optional((CaselessLiteral(":") + type_label)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="generic_entity_type"))("generic_entity_type") + generic_type = ((GENERIC + Optional((CaselessLiteral(":") + type_label)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="generic_type"))("generic_type") + literal = ((binary_literal | logical_literal | real_literal | string_literal)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="literal"))("literal") + resource_or_rename = ((resource_ref + Optional((AS + rename_id)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="resource_or_rename"))("resource_or_rename") schema_version_id = (string_literal)("schema_version_id") - select_extension = ((BASED_ON + type_ref + Optional((WITH + select_list)))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="select_extension") - )("select_extension") - select_type = ( - (Optional((EXTENSIBLE + Optional(GENERIC_ENTITY))) + SELECT + Optional((select_list | select_extension))) - ).setParseAction(SelectType)("select_type") - unique_clause = ( - (UNIQUE + unique_rule + CaselessLiteral(";") + ZeroOrMore((unique_rule + CaselessLiteral(";")))) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="unique_clause"))("unique_clause") - lparen_then_not_lparen_star = ( - (CaselessLiteral("(") + ZeroOrMore(CaselessLiteral("(")) + not_lparen_star + ZeroOrMore(not_lparen_star)) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="lparen_then_not_lparen_star"))( - "lparen_then_not_lparen_star" - ) - remark_tag = ( - (CaselessLiteral('"') + remark_ref + ZeroOrMore((CaselessLiteral(".") + remark_ref)) + CaselessLiteral('"')) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="remark_tag"))("remark_tag") - tail_remark = ((CaselessLiteral("--") + Optional(remark_tag))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="tail_remark") - )("tail_remark") - constructed_types = ((enumeration_type | select_type)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="constructed_types") - )("constructed_types") - reference_clause = ( - ( - REFERENCE - + FROM - + schema_ref - + Optional( - ( - CaselessLiteral("(") - + resource_or_rename - + ZeroOrMore((CaselessLiteral(",") + resource_or_rename)) - + CaselessLiteral(")") - ) - ) - + CaselessLiteral(";") - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="reference_clause"))("reference_clause") - interface_specification = ((reference_clause | use_clause)).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="interface_specification") - )("interface_specification") - binary_type = Forward()("binary_type") - function_decl = Forward()("function_decl") - general_set_type = Forward()("general_set_type") - actual_parameter_list = Forward()("actual_parameter_list") - if_stmt = Forward()("if_stmt") - simple_factor = Forward()("simple_factor") - case_stmt = Forward()("case_stmt") - qualifier = Forward()("qualifier") - general_list_type = Forward()("general_list_type") - interval = Forward()("interval") - set_type = Forward()("set_type") - return_stmt = Forward()("return_stmt") - schema_decl = Forward()("schema_decl") - bound_spec = Forward()("bound_spec") - supertype_factor = Forward()("supertype_factor") - logical_expression = Forward()("logical_expression") - numeric_expression = Forward()("numeric_expression") - repeat_control = Forward()("repeat_control") - qualifiable_factor = Forward()("qualifiable_factor") - inverse_attr = Forward()("inverse_attr") - increment_control = Forward()("increment_control") - compound_stmt = Forward()("compound_stmt") - until_control = Forward()("until_control") - remark = Forward()("remark") - simple_expression = Forward()("simple_expression") - instantiable_type = Forward()("instantiable_type") - constant_body = Forward()("constant_body") - inverse_clause = Forward()("inverse_clause") - query_expression = Forward()("query_expression") - repeat_stmt = Forward()("repeat_stmt") - increment = Forward()("increment") - aggregate_type = Forward()("aggregate_type") - index_1 = Forward()("index_1") - bound_2 = Forward()("bound_2") - factor = Forward()("factor") - interval_item = Forward()("interval_item") - type_decl = Forward()("type_decl") - supertype_rule = Forward()("supertype_rule") - assignment_stmt = Forward()("assignment_stmt") - interval_low = Forward()("interval_low") - concrete_types = Forward()("concrete_types") - element = Forward()("element") - string_type = Forward()("string_type") - procedure_decl = Forward()("procedure_decl") - width_spec = Forward()("width_spec") - alias_stmt = Forward()("alias_stmt") - subtype_constraint = Forward()("subtype_constraint") - index = Forward()("index") - declaration = Forward()("declaration") - real_type = Forward()("real_type") - index_qualifier = Forward()("index_qualifier") - generalized_types = Forward()("generalized_types") - constant_decl = Forward()("constant_decl") - precision_spec = Forward()("precision_spec") - function_head = Forward()("function_head") - derive_clause = Forward()("derive_clause") - function_call = Forward()("function_call") - case_label = Forward()("case_label") - supertype_expression = Forward()("supertype_expression") - procedure_head = Forward()("procedure_head") - derived_attr = Forward()("derived_attr") - bag_type = Forward()("bag_type") - term = Forward()("term") - supertype_constraint = Forward()("supertype_constraint") - aggregate_source = Forward()("aggregate_source") - where_clause = Forward()("where_clause") - repetition = Forward()("repetition") - abstract_supertype_declaration = Forward()("abstract_supertype_declaration") - domain_rule = Forward()("domain_rule") - index_2 = Forward()("index_2") - subsuper = Forward()("subsuper") - supertype_term = Forward()("supertype_term") - underlying_type = Forward()("underlying_type") - subtype_constraint_decl = Forward()("subtype_constraint_decl") - parameter = Forward()("parameter") - rule_decl = Forward()("rule_decl") - case_action = Forward()("case_action") - local_decl = Forward()("local_decl") - primary = Forward()("primary") - one_of = Forward()("one_of") - local_variable = Forward()("local_variable") - entity_head = Forward()("entity_head") - formal_parameter = Forward()("formal_parameter") - array_type = Forward()("array_type") - subtype_constraint_body = Forward()("subtype_constraint_body") - explicit_attr = Forward()("explicit_attr") - general_bag_type = Forward()("general_bag_type") - while_control = Forward()("while_control") - schema_body = Forward()("schema_body") + select_extension = ((BASED_ON + type_ref + Optional((WITH + select_list)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="select_extension"))("select_extension") + select_type = ((Optional((EXTENSIBLE + Optional(GENERIC_ENTITY))) + SELECT + Optional((select_list | select_extension)))).setParseAction(SelectType)("select_type") + unique_clause = ((UNIQUE + unique_rule + CaselessLiteral(";") + ZeroOrMore((unique_rule + CaselessLiteral(";"))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="unique_clause"))("unique_clause") + lparen_then_not_lparen_star = ((CaselessLiteral("(") + ZeroOrMore(CaselessLiteral("(")) + not_lparen_star + ZeroOrMore(not_lparen_star))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="lparen_then_not_lparen_star"))("lparen_then_not_lparen_star") + remark_tag = ((CaselessLiteral("\"") + remark_ref + ZeroOrMore((CaselessLiteral(".") + remark_ref)) + CaselessLiteral("\""))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="remark_tag"))("remark_tag") + tail_remark = ((CaselessLiteral("--") + Optional(remark_tag))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="tail_remark"))("tail_remark") + constructed_types = ((enumeration_type | select_type)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="constructed_types"))("constructed_types") + reference_clause = ((REFERENCE + FROM + schema_ref + Optional((CaselessLiteral("(") + resource_or_rename + ZeroOrMore((CaselessLiteral(",") + resource_or_rename)) + CaselessLiteral(")"))) + CaselessLiteral(";"))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="reference_clause"))("reference_clause") + interface_specification = ((reference_clause | use_clause)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="interface_specification"))("interface_specification") list_type = Forward()("list_type") - entity_constructor = Forward()("entity_constructor") - syntax = Forward()("syntax") - entity_decl = Forward()("entity_decl") - algorithm_head = Forward()("algorithm_head") - general_array_type = Forward()("general_array_type") - entity_body = Forward()("entity_body") - aggregation_types = Forward()("aggregation_types") - selector = Forward()("selector") - embedded_remark = Forward()("embedded_remark") - aggregate_initializer = Forward()("aggregate_initializer") parameter_type = Forward()("parameter_type") - general_aggregation_types = Forward()("general_aggregation_types") - bound_1 = Forward()("bound_1") - stmt = Forward()("stmt") + qualifiable_factor = Forward()("qualifiable_factor") + supertype_expression = Forward()("supertype_expression") + precision_spec = Forward()("precision_spec") + element = Forward()("element") + subtype_constraint_decl = Forward()("subtype_constraint_decl") + derived_attr = Forward()("derived_attr") + general_bag_type = Forward()("general_bag_type") + aggregation_types = Forward()("aggregation_types") + entity_decl = Forward()("entity_decl") + rule_decl = Forward()("rule_decl") + numeric_expression = Forward()("numeric_expression") + increment = Forward()("increment") + supertype_constraint = Forward()("supertype_constraint") + concrete_types = Forward()("concrete_types") + remark = Forward()("remark") width = Forward()("width") + index = Forward()("index") + selector = Forward()("selector") + simple_factor = Forward()("simple_factor") + actual_parameter_list = Forward()("actual_parameter_list") + general_set_type = Forward()("general_set_type") + declaration = Forward()("declaration") + repeat_stmt = Forward()("repeat_stmt") + until_control = Forward()("until_control") + supertype_factor = Forward()("supertype_factor") + one_of = Forward()("one_of") procedure_call_stmt = Forward()("procedure_call_stmt") + repetition = Forward()("repetition") + case_action = Forward()("case_action") + inverse_attr = Forward()("inverse_attr") + aggregate_initializer = Forward()("aggregate_initializer") + bound_spec = Forward()("bound_spec") interval_high = Forward()("interval_high") + algorithm_head = Forward()("algorithm_head") + real_type = Forward()("real_type") + case_stmt = Forward()("case_stmt") + constant_decl = Forward()("constant_decl") + alias_stmt = Forward()("alias_stmt") + function_head = Forward()("function_head") + interval_low = Forward()("interval_low") + aggregate_source = Forward()("aggregate_source") + query_expression = Forward()("query_expression") + width_spec = Forward()("width_spec") + interval_item = Forward()("interval_item") + subsuper = Forward()("subsuper") + array_type = Forward()("array_type") + primary = Forward()("primary") + case_label = Forward()("case_label") + index_1 = Forward()("index_1") + entity_constructor = Forward()("entity_constructor") + subtype_constraint_body = Forward()("subtype_constraint_body") + constant_body = Forward()("constant_body") + explicit_attr = Forward()("explicit_attr") + entity_body = Forward()("entity_body") + repeat_control = Forward()("repeat_control") expression = Forward()("expression") + if_stmt = Forward()("if_stmt") + subtype_constraint = Forward()("subtype_constraint") + while_control = Forward()("while_control") + logical_expression = Forward()("logical_expression") + aggregate_type = Forward()("aggregate_type") + interval = Forward()("interval") + general_array_type = Forward()("general_array_type") + underlying_type = Forward()("underlying_type") + instantiable_type = Forward()("instantiable_type") + supertype_rule = Forward()("supertype_rule") + generalized_types = Forward()("generalized_types") + local_variable = Forward()("local_variable") + schema_body = Forward()("schema_body") + general_list_type = Forward()("general_list_type") + assignment_stmt = Forward()("assignment_stmt") + bound_2 = Forward()("bound_2") + binary_type = Forward()("binary_type") + syntax = Forward()("syntax") + parameter = Forward()("parameter") + string_type = Forward()("string_type") + supertype_term = Forward()("supertype_term") + embedded_remark = Forward()("embedded_remark") + increment_control = Forward()("increment_control") + local_decl = Forward()("local_decl") + factor = Forward()("factor") + procedure_head = Forward()("procedure_head") + function_decl = Forward()("function_decl") + type_decl = Forward()("type_decl") + general_aggregation_types = Forward()("general_aggregation_types") + domain_rule = Forward()("domain_rule") + schema_decl = Forward()("schema_decl") + derive_clause = Forward()("derive_clause") + return_stmt = Forward()("return_stmt") + bag_type = Forward()("bag_type") + procedure_decl = Forward()("procedure_decl") + abstract_supertype_declaration = Forward()("abstract_supertype_declaration") + inverse_clause = Forward()("inverse_clause") + index_qualifier = Forward()("index_qualifier") + bound_1 = Forward()("bound_1") + compound_stmt = Forward()("compound_stmt") + set_type = Forward()("set_type") + where_clause = Forward()("where_clause") + qualifier = Forward()("qualifier") + entity_head = Forward()("entity_head") + stmt = Forward()("stmt") + index_2 = Forward()("index_2") + term = Forward()("term") + function_call = Forward()("function_call") + formal_parameter = Forward()("formal_parameter") + simple_expression = Forward()("simple_expression") simple_types = Forward()("simple_types") - binary_type << (((BINARY + Optional(width_spec)))).setParseAction(BinaryType) - function_decl << ( - ((function_head + algorithm_head + stmt + ZeroOrMore(stmt) + END_FUNCTION + CaselessLiteral(";"))) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="function_decl")) - general_set_type << (((SET + Optional(bound_spec) + OF + parameter_type))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="general_set_type") - ) - actual_parameter_list << ( - ( - ( - CaselessLiteral("(") - + Optional(parameter) - + ZeroOrMore((CaselessLiteral(",") + parameter)) - + CaselessLiteral(")") - ) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="actual_parameter_list")) - if_stmt << ( - ( - ( - IF - + logical_expression - + THEN - + stmt - + ZeroOrMore(stmt) - + Optional((ELSE + stmt + ZeroOrMore(stmt))) - + END_IF - + CaselessLiteral(";") - ) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="if_stmt")) - simple_factor << ( - ( - ( - aggregate_initializer - | interval - | query_expression - | (Optional(unary_op) + ((CaselessLiteral("(") + expression + CaselessLiteral(")")) | primary)) - | entity_constructor - | enumeration_reference - ) - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="simple_factor")) - case_stmt << ( - ( - ( - CASE - + selector - + OF - + ZeroOrMore(case_action) - + Optional((OTHERWISE + CaselessLiteral(":") + stmt)) - + END_CASE - + CaselessLiteral(";") - ) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="case_stmt")) - qualifier << (((attribute_qualifier | group_qualifier | index_qualifier))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="qualifier") - ) - general_list_type << (((LIST + Optional(bound_spec) + OF + Optional(UNIQUE) + parameter_type))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="general_list_type") - ) - interval << ( - ( - ( - CaselessLiteral("{") - + interval_low - + interval_op - + interval_item - + interval_op - + interval_high - + CaselessLiteral("}") - ) - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="interval")) - set_type << (((SET + Optional(bound_spec) + OF + instantiable_type))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="set_type") - ) - return_stmt << ( - ((RETURN + Optional((CaselessLiteral("(") + expression + CaselessLiteral(")"))) + CaselessLiteral(";"))) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="return_stmt")) - schema_decl << ( - ( - ( - SCHEMA - + schema_id - + Optional(schema_version_id) - + CaselessLiteral(";") - + schema_body - + END_SCHEMA - + CaselessLiteral(";") - ) - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="schema_decl")) - bound_spec << ( - ((CaselessLiteral("[") + bound_1 + CaselessLiteral(":") + bound_2 + CaselessLiteral("]"))) - ).setParseAction(BoundSpecification) - supertype_factor << (((supertype_term + ZeroOrMore((AND + supertype_term))))).setParseAction( - lambda s, loc, t: ListNode(s, loc, t, rule="supertype_factor") - ) - logical_expression << (expression) - numeric_expression << (simple_expression) - repeat_control << ( - ((Optional(increment_control) + Optional(while_control) + Optional(until_control))) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="repeat_control")) - qualifiable_factor << ( - ((function_call | attribute_ref | constant_factor | general_ref | population)) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="qualifiable_factor")) - inverse_attr << ( - ( - ( - attribute_decl - + CaselessLiteral(":") - + Optional(((SET | BAG) + Optional(bound_spec) + OF)) - + entity_ref - + FOR - + Optional((entity_ref + CaselessLiteral("."))) - + attribute_ref - + CaselessLiteral(";") - ) - ) - ).setParseAction(InverseAttribute) - increment_control << ( - ((variable_id + CaselessLiteral(":=") + bound_1 + TO + bound_2 + Optional((BY + increment)))) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="increment_control")) - compound_stmt << (((BEGIN + stmt + ZeroOrMore(stmt) + END + CaselessLiteral(";")))).setParseAction( - lambda s, loc, t: ListNode(s, loc, t, rule="compound_stmt") - ) - until_control << (((UNTIL + logical_expression))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="until_control") - ) - remark << (((embedded_remark | tail_remark))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="remark")) - simple_expression << (((term + ZeroOrMore((add_like_op + term))))).setParseAction( - lambda s, loc, t: ListNode(s, loc, t, rule="simple_expression") - ) - instantiable_type << (((concrete_types | entity_ref))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="instantiable_type") - ) - constant_body << ( - ( - ( - constant_id - + CaselessLiteral(":") - + instantiable_type - + CaselessLiteral(":=") - + expression - + CaselessLiteral(";") - ) - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="constant_body")) - inverse_clause << (((INVERSE + inverse_attr + ZeroOrMore(inverse_attr)))).setParseAction(AttributeList) - query_expression << ( - ( - ( - QUERY - + CaselessLiteral("(") - + variable_id - + CaselessLiteral("<*") - + aggregate_source - + CaselessLiteral("|") - + logical_expression - + CaselessLiteral(")") - ) - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="query_expression")) - repeat_stmt << ( - ( - ( - REPEAT - + repeat_control - + CaselessLiteral(";") - + stmt - + ZeroOrMore(stmt) - + END_REPEAT - + CaselessLiteral(";") - ) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="repeat_stmt")) - increment << (numeric_expression) - aggregate_type << ( - ((AGGREGATE + Optional((CaselessLiteral(":") + type_label)) + OF + parameter_type)) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="aggregate_type")) - index_1 << (index) - bound_2 << (numeric_expression) - factor << (((simple_factor + Optional((CaselessLiteral("**") + simple_factor))))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="factor") - ) - interval_item << (simple_expression) - type_decl << ( - ( - ( - TYPE - + type_id - + CaselessLiteral("=") - + underlying_type - + CaselessLiteral(";") - + Optional(where_clause) - + END_TYPE - + CaselessLiteral(";") - ) - ) - ).setParseAction(TypeDeclaration) - supertype_rule << (((SUPERTYPE + subtype_constraint))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="supertype_rule") - ) - assignment_stmt << ( - ((general_ref + ZeroOrMore(qualifier) + CaselessLiteral(":=") + expression + CaselessLiteral(";"))) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="assignment_stmt")) - interval_low << (simple_expression) - concrete_types << (((aggregation_types | simple_types | type_ref))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="concrete_types") - ) - element << (((expression + Optional((CaselessLiteral(":") + repetition))))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="element") - ) - string_type << (((STRING + Optional(width_spec)))).setParseAction(StringType) - procedure_decl << ( - ((procedure_head + algorithm_head + ZeroOrMore(stmt) + END_PROCEDURE + CaselessLiteral(";"))) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="procedure_decl")) - width_spec << (((CaselessLiteral("(") + width + CaselessLiteral(")") + Optional(FIXED)))).setParseAction( - WidthSpec - ) - alias_stmt << ( - ( - ( - ALIAS - + variable_id - + FOR - + general_ref - + ZeroOrMore(qualifier) - + CaselessLiteral(";") - + stmt - + ZeroOrMore(stmt) - + END_ALIAS - + CaselessLiteral(";") - ) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="alias_stmt")) - subtype_constraint << ( - ((OF + CaselessLiteral("(") + supertype_expression + CaselessLiteral(")"))) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint")) - index << (numeric_expression) - declaration << ( - ((entity_decl | function_decl | procedure_decl | subtype_constraint_decl | type_decl)) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="declaration")) - real_type << ( - ((REAL + Optional((CaselessLiteral("(") + precision_spec + CaselessLiteral(")"))))) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="real_type")) - index_qualifier << ( - ((CaselessLiteral("[") + index_1 + Optional((CaselessLiteral(":") + index_2)) + CaselessLiteral("]"))) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="index_qualifier")) - generalized_types << ( - ((aggregate_type | general_aggregation_types | generic_entity_type | generic_type)) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="generalized_types")) - constant_decl << ( - ((CONSTANT + constant_body + ZeroOrMore(constant_body) + END_CONSTANT + CaselessLiteral(";"))) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="constant_decl")) + list_type << (((LIST + Optional(bound_spec) + OF + Optional(UNIQUE) + instantiable_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="list_type")) + parameter_type << (((generalized_types | simple_types | named_types))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="parameter_type")) + qualifiable_factor << (((function_call | attribute_ref | constant_factor | general_ref | population))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="qualifiable_factor")) + supertype_expression << (((supertype_factor + ZeroOrMore((ANDOR + supertype_factor))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="supertype_expression")) precision_spec << (numeric_expression) - function_head << ( - ( - ( - FUNCTION - + function_id - + Optional( - ( - CaselessLiteral("(") - + formal_parameter - + ZeroOrMore((CaselessLiteral(";") + formal_parameter)) - + CaselessLiteral(")") - ) - ) - + CaselessLiteral(":") - + parameter_type - + CaselessLiteral(";") - ) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="function_head")) - derive_clause << (((DERIVE + derived_attr + ZeroOrMore(derived_attr)))).setParseAction(AttributeList) - function_call << ((((built_in_function | function_ref) + actual_parameter_list))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="function_call") - ) - case_label << (expression) - supertype_expression << (((supertype_factor + ZeroOrMore((ANDOR + supertype_factor))))).setParseAction( - lambda s, loc, t: ListNode(s, loc, t, rule="supertype_expression") - ) - procedure_head << ( - ( - ( - PROCEDURE - + procedure_id - + Optional( - ( - CaselessLiteral("(") - + Optional(VAR) - + formal_parameter - + ZeroOrMore((CaselessLiteral(";") + Optional(VAR) + formal_parameter)) - + CaselessLiteral(")") - ) - ) - + CaselessLiteral(";") - ) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="procedure_head")) - derived_attr << ( - ( - ( - attribute_decl - + CaselessLiteral(":") - + parameter_type - + CaselessLiteral(":=") - + expression - + CaselessLiteral(";") - ) - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="derived_attr")) - bag_type << (((BAG + Optional(bound_spec) + OF + instantiable_type))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="bag_type") - ) - term << (((factor + ZeroOrMore((multiplication_like_op + factor))))).setParseAction( - lambda s, loc, t: ListNode(s, loc, t, rule="term") - ) - supertype_constraint << ( - ((abstract_supertype_declaration | abstract_entity_declaration | supertype_rule)) - ).setParseAction(SuperTypeExpression) - aggregate_source << (simple_expression) - where_clause << ( - ((WHERE + domain_rule + CaselessLiteral(";") + ZeroOrMore((domain_rule + CaselessLiteral(";"))))) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="where_clause")) - repetition << (numeric_expression) - abstract_supertype_declaration << (((ABSTRACT + SUPERTYPE + Optional(subtype_constraint)))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="abstract_supertype_declaration") - ) - domain_rule << (((Optional((rule_label_id + CaselessLiteral(":"))) + expression))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="domain_rule") - ) - index_2 << (index) - subsuper << (((Optional(supertype_constraint) + Optional(subtype_declaration)))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="subsuper") - ) - supertype_term << ( - ((one_of | (CaselessLiteral("(") + supertype_expression + CaselessLiteral(")")) | entity_ref)) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="supertype_term")) - underlying_type << (((constructed_types | concrete_types))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="underlying_type") - ) - subtype_constraint_decl << ( - ((subtype_constraint_head + subtype_constraint_body + END_SUBTYPE_CONSTRAINT + CaselessLiteral(";"))) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint_decl")) - parameter << (expression) - rule_decl << ( - ((rule_head + algorithm_head + ZeroOrMore(stmt) + where_clause + END_RULE + CaselessLiteral(";"))) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="rule_decl")) - case_action << ( - ((case_label + ZeroOrMore((CaselessLiteral(",") + case_label)) + CaselessLiteral(":") + stmt)) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="case_action")) - local_decl << ( - ((LOCAL + local_variable + ZeroOrMore(local_variable) + END_LOCAL + CaselessLiteral(";"))) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="local_decl")) - primary << (((literal | (qualifiable_factor + ZeroOrMore(qualifier))))).setParseAction( - lambda s, loc, t: ListNode(s, loc, t, rule="primary") - ) - one_of << ( - ( - ( - ONEOF - + CaselessLiteral("(") - + supertype_expression - + ZeroOrMore((CaselessLiteral(",") + supertype_expression)) - + CaselessLiteral(")") - ) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="one_of")) - local_variable << ( - ( - ( - variable_id - + ZeroOrMore((CaselessLiteral(",") + variable_id)) - + CaselessLiteral(":") - + parameter_type - + Optional((CaselessLiteral(":=") + expression)) - + CaselessLiteral(";") - ) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="local_variable")) - entity_head << (((ENTITY + entity_id + subsuper + CaselessLiteral(";")))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="entity_head") - ) - formal_parameter << ( - ((parameter_id + ZeroOrMore((CaselessLiteral(",") + parameter_id)) + CaselessLiteral(":") + parameter_type)) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="formal_parameter")) - array_type << ( - ((ARRAY + bound_spec + OF + Optional(OPTIONAL) + Optional(UNIQUE) + instantiable_type)) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="array_type")) - subtype_constraint_body << ( - ( - ( - Optional(abstract_supertype) - + Optional(total_over) - + Optional((supertype_expression + CaselessLiteral(";"))) - ) - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint_body")) - explicit_attr << ( - ( - ( - attribute_decl - + ZeroOrMore((CaselessLiteral(",") + attribute_decl)) - + CaselessLiteral(":") - + Optional(OPTIONAL) - + parameter_type - + CaselessLiteral(";") - ) - ) - ).setParseAction(ExplicitAttribute) - general_bag_type << (((BAG + Optional(bound_spec) + OF + parameter_type))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="general_bag_type") - ) - while_control << (((WHILE + logical_expression))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="while_control") - ) - schema_body << ( - ((ZeroOrMore(interface_specification) + Optional(constant_decl) + ZeroOrMore((declaration | rule_decl)))) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="schema_body")) - list_type << (((LIST + Optional(bound_spec) + OF + Optional(UNIQUE) + instantiable_type))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="list_type") - ) - entity_constructor << ( - ( - ( - entity_ref - + CaselessLiteral("(") - + Optional((expression + ZeroOrMore((CaselessLiteral(",") + expression)))) - + CaselessLiteral(")") - ) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="entity_constructor")) - syntax << (((schema_decl + ZeroOrMore(schema_decl)))).setParseAction( - lambda s, loc, t: ListNode(s, loc, t, rule="syntax") - ) - entity_decl << (((entity_head + entity_body + END_ENTITY + CaselessLiteral(";")))).setParseAction( - EntityDeclaration - ) - algorithm_head << (((ZeroOrMore(declaration) + Optional(constant_decl) + Optional(local_decl)))).setParseAction( - lambda s, loc, t: ListNode(s, loc, t, rule="algorithm_head") - ) - general_array_type << ( - ((ARRAY + Optional(bound_spec) + OF + Optional(OPTIONAL) + Optional(UNIQUE) + parameter_type)) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_array_type")) - entity_body << ( - ( - ( - ZeroOrMore(explicit_attr) - + Optional(derive_clause) - + Optional(inverse_clause) - + Optional(unique_clause) - + Optional(where_clause) - ) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="entity_body")) + element << (((expression + Optional((CaselessLiteral(":") + repetition))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="element")) + subtype_constraint_decl << (((subtype_constraint_head + subtype_constraint_body + END_SUBTYPE_CONSTRAINT + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint_decl")) + derived_attr << (((attribute_decl + CaselessLiteral(":") + parameter_type + CaselessLiteral(":=") + expression + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="derived_attr")) + general_bag_type << (((BAG + Optional(bound_spec) + OF + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_bag_type")) aggregation_types << (((array_type | bag_type | list_type | set_type))).setParseAction(AggregationType) - selector << (expression) - embedded_remark << ( - ( - ( - CaselessLiteral("(*") - + Optional(remark_tag) - + ZeroOrMore( - ( - (not_paren_star + ZeroOrMore(not_paren_star)) - | lparen_then_not_lparen_star - | (CaselessLiteral("*") + ZeroOrMore(CaselessLiteral("*"))) - | not_rparen_star_then_rparen - | embedded_remark - ) - ) - + CaselessLiteral("*)") - ) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="embedded_remark")) - aggregate_initializer << ( - ( - ( - CaselessLiteral("[") - + Optional((element + ZeroOrMore((CaselessLiteral(",") + element)))) - + CaselessLiteral("]") - ) - ) - ).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="aggregate_initializer")) - parameter_type << (((generalized_types | simple_types | named_types))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="parameter_type") - ) - general_aggregation_types << ( - ((general_array_type | general_bag_type | general_list_type | general_set_type)) - ).setParseAction(AggregationType) - bound_1 << (numeric_expression) - stmt << ( - ( - ( - alias_stmt - | assignment_stmt - | case_stmt - | compound_stmt - | escape_stmt - | if_stmt - | null_stmt - | procedure_call_stmt - | repeat_stmt - | return_stmt - | skip_stmt - ) - ) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="stmt")) + entity_decl << (((entity_head + entity_body + END_ENTITY + CaselessLiteral(";")))).setParseAction(EntityDeclaration) + rule_decl << (((rule_head + algorithm_head + ZeroOrMore(stmt) + where_clause + END_RULE + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="rule_decl")) + numeric_expression << (simple_expression) + increment << (numeric_expression) + supertype_constraint << (((abstract_supertype_declaration | abstract_entity_declaration | supertype_rule))).setParseAction(SuperTypeExpression) + concrete_types << (((aggregation_types | simple_types | type_ref))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="concrete_types")) + remark << (((embedded_remark | tail_remark))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="remark")) width << (numeric_expression) - procedure_call_stmt << ( - (((built_in_procedure | procedure_ref) + actual_parameter_list + CaselessLiteral(";"))) - ).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="procedure_call_stmt")) + index << (numeric_expression) + selector << (expression) + simple_factor << (((aggregate_initializer | interval | query_expression | (Optional(unary_op) + ((CaselessLiteral("(") + expression + CaselessLiteral(")")) | primary)) | entity_constructor | enumeration_reference))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="simple_factor")) + actual_parameter_list << (((CaselessLiteral("(") + Optional(parameter) + ZeroOrMore((CaselessLiteral(",") + parameter)) + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="actual_parameter_list")) + general_set_type << (((SET + Optional(bound_spec) + OF + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_set_type")) + declaration << (((entity_decl | function_decl | procedure_decl | subtype_constraint_decl | type_decl))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="declaration")) + repeat_stmt << (((REPEAT + repeat_control + CaselessLiteral(";") + stmt + ZeroOrMore(stmt) + END_REPEAT + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="repeat_stmt")) + until_control << (((UNTIL + logical_expression))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="until_control")) + supertype_factor << (((supertype_term + ZeroOrMore((AND + supertype_term))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="supertype_factor")) + one_of << (((ONEOF + CaselessLiteral("(") + supertype_expression + ZeroOrMore((CaselessLiteral(",") + supertype_expression)) + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="one_of")) + procedure_call_stmt << ((((built_in_procedure | procedure_ref) + actual_parameter_list + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="procedure_call_stmt")) + repetition << (numeric_expression) + case_action << (((case_label + ZeroOrMore((CaselessLiteral(",") + case_label)) + CaselessLiteral(":") + stmt))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="case_action")) + inverse_attr << (((attribute_decl + CaselessLiteral(":") + Optional(((SET | BAG) + Optional(bound_spec) + OF)) + entity_ref + FOR + Optional((entity_ref + CaselessLiteral("."))) + attribute_ref + CaselessLiteral(";")))).setParseAction(InverseAttribute) + aggregate_initializer << (((CaselessLiteral("[") + Optional((element + ZeroOrMore((CaselessLiteral(",") + element)))) + CaselessLiteral("]")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="aggregate_initializer")) + bound_spec << (((CaselessLiteral("[") + bound_1 + CaselessLiteral(":") + bound_2 + CaselessLiteral("]")))).setParseAction(BoundSpecification) interval_high << (simple_expression) - expression << (((simple_expression + Optional((rel_op_extended + simple_expression))))).setParseAction( - lambda s, loc, t: Node(s, loc, t, rule="expression") - ) - simple_types << ( - ((binary_type | boolean_type | integer_type | logical_type | number_type | real_type | string_type)) - ).setParseAction(SimpleType) + algorithm_head << (((ZeroOrMore(declaration) + Optional(constant_decl) + Optional(local_decl)))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="algorithm_head")) + real_type << (((REAL + Optional((CaselessLiteral("(") + precision_spec + CaselessLiteral(")")))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="real_type")) + case_stmt << (((CASE + selector + OF + ZeroOrMore(case_action) + Optional((OTHERWISE + CaselessLiteral(":") + stmt)) + END_CASE + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="case_stmt")) + constant_decl << (((CONSTANT + constant_body + ZeroOrMore(constant_body) + END_CONSTANT + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="constant_decl")) + alias_stmt << (((ALIAS + variable_id + FOR + general_ref + ZeroOrMore(qualifier) + CaselessLiteral(";") + stmt + ZeroOrMore(stmt) + END_ALIAS + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="alias_stmt")) + function_head << (((FUNCTION + function_id + Optional((CaselessLiteral("(") + formal_parameter + ZeroOrMore((CaselessLiteral(";") + formal_parameter)) + CaselessLiteral(")"))) + CaselessLiteral(":") + parameter_type + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="function_head")) + interval_low << (simple_expression) + aggregate_source << (simple_expression) + query_expression << (((QUERY + CaselessLiteral("(") + variable_id + CaselessLiteral("<*") + aggregate_source + CaselessLiteral("|") + logical_expression + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="query_expression")) + width_spec << (((CaselessLiteral("(") + width + CaselessLiteral(")") + Optional(FIXED)))).setParseAction(WidthSpec) + interval_item << (simple_expression) + subsuper << (((Optional(supertype_constraint) + Optional(subtype_declaration)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subsuper")) + array_type << (((ARRAY + bound_spec + OF + Optional(OPTIONAL) + Optional(UNIQUE) + instantiable_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="array_type")) + primary << (((literal | (qualifiable_factor + ZeroOrMore(qualifier))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="primary")) + case_label << (expression) + index_1 << (index) + entity_constructor << (((entity_ref + CaselessLiteral("(") + Optional((expression + ZeroOrMore((CaselessLiteral(",") + expression)))) + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="entity_constructor")) + subtype_constraint_body << (((Optional(abstract_supertype) + Optional(total_over) + Optional((supertype_expression + CaselessLiteral(";")))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint_body")) + constant_body << (((constant_id + CaselessLiteral(":") + instantiable_type + CaselessLiteral(":=") + expression + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="constant_body")) + explicit_attr << (((attribute_decl + ZeroOrMore((CaselessLiteral(",") + attribute_decl)) + CaselessLiteral(":") + Optional(OPTIONAL) + parameter_type + CaselessLiteral(";")))).setParseAction(ExplicitAttribute) + entity_body << (((ZeroOrMore(explicit_attr) + Optional(derive_clause) + Optional(inverse_clause) + Optional(unique_clause) + Optional(where_clause)))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="entity_body")) + repeat_control << (((Optional(increment_control) + Optional(while_control) + Optional(until_control)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="repeat_control")) + expression << (((simple_expression + Optional((rel_op_extended + simple_expression))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="expression")) + if_stmt << (((IF + logical_expression + THEN + stmt + ZeroOrMore(stmt) + Optional((ELSE + stmt + ZeroOrMore(stmt))) + END_IF + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="if_stmt")) + subtype_constraint << (((OF + CaselessLiteral("(") + supertype_expression + CaselessLiteral(")")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="subtype_constraint")) + while_control << (((WHILE + logical_expression))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="while_control")) + logical_expression << (expression) + aggregate_type << (((AGGREGATE + Optional((CaselessLiteral(":") + type_label)) + OF + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="aggregate_type")) + interval << (((CaselessLiteral("{") + interval_low + interval_op + interval_item + interval_op + interval_high + CaselessLiteral("}")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="interval")) + general_array_type << (((ARRAY + Optional(bound_spec) + OF + Optional(OPTIONAL) + Optional(UNIQUE) + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_array_type")) + underlying_type << (((constructed_types | concrete_types))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="underlying_type")) + instantiable_type << (((concrete_types | entity_ref))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="instantiable_type")) + supertype_rule << (((SUPERTYPE + subtype_constraint))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="supertype_rule")) + generalized_types << (((aggregate_type | general_aggregation_types | generic_entity_type | generic_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="generalized_types")) + local_variable << (((variable_id + ZeroOrMore((CaselessLiteral(",") + variable_id)) + CaselessLiteral(":") + parameter_type + Optional((CaselessLiteral(":=") + expression)) + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="local_variable")) + schema_body << (((ZeroOrMore(interface_specification) + Optional(constant_decl) + ZeroOrMore((declaration | rule_decl))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="schema_body")) + general_list_type << (((LIST + Optional(bound_spec) + OF + Optional(UNIQUE) + parameter_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="general_list_type")) + assignment_stmt << (((general_ref + ZeroOrMore(qualifier) + CaselessLiteral(":=") + expression + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="assignment_stmt")) + bound_2 << (numeric_expression) + binary_type << (((BINARY + Optional(width_spec)))).setParseAction(BinaryType) + syntax << (((schema_decl + ZeroOrMore(schema_decl)))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="syntax")) + parameter << (expression) + string_type << (((STRING + Optional(width_spec)))).setParseAction(StringType) + supertype_term << (((one_of | (CaselessLiteral("(") + supertype_expression + CaselessLiteral(")")) | entity_ref))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="supertype_term")) + embedded_remark << (((CaselessLiteral("(*") + Optional(remark_tag) + ZeroOrMore(((not_paren_star + ZeroOrMore(not_paren_star)) | lparen_then_not_lparen_star | (CaselessLiteral("*") + ZeroOrMore(CaselessLiteral("*"))) | not_rparen_star_then_rparen | embedded_remark)) + CaselessLiteral("*)")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="embedded_remark")) + increment_control << (((variable_id + CaselessLiteral(":=") + bound_1 + TO + bound_2 + Optional((BY + increment))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="increment_control")) + local_decl << (((LOCAL + local_variable + ZeroOrMore(local_variable) + END_LOCAL + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="local_decl")) + factor << (((simple_factor + Optional((CaselessLiteral("**") + simple_factor))))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="factor")) + procedure_head << (((PROCEDURE + procedure_id + Optional((CaselessLiteral("(") + Optional(VAR) + formal_parameter + ZeroOrMore((CaselessLiteral(";") + Optional(VAR) + formal_parameter)) + CaselessLiteral(")"))) + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="procedure_head")) + function_decl << (((function_head + algorithm_head + stmt + ZeroOrMore(stmt) + END_FUNCTION + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="function_decl")) + type_decl << (((TYPE + type_id + CaselessLiteral("=") + underlying_type + CaselessLiteral(";") + Optional(where_clause) + END_TYPE + CaselessLiteral(";")))).setParseAction(TypeDeclaration) + general_aggregation_types << (((general_array_type | general_bag_type | general_list_type | general_set_type))).setParseAction(AggregationType) + domain_rule << (((Optional((rule_label_id + CaselessLiteral(":"))) + expression))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="domain_rule")) + schema_decl << (((SCHEMA + schema_id + Optional(schema_version_id) + CaselessLiteral(";") + schema_body + END_SCHEMA + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="schema_decl")) + derive_clause << (((DERIVE + derived_attr + ZeroOrMore(derived_attr)))).setParseAction(AttributeList) + return_stmt << (((RETURN + Optional((CaselessLiteral("(") + expression + CaselessLiteral(")"))) + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="return_stmt")) + bag_type << (((BAG + Optional(bound_spec) + OF + instantiable_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="bag_type")) + procedure_decl << (((procedure_head + algorithm_head + ZeroOrMore(stmt) + END_PROCEDURE + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="procedure_decl")) + abstract_supertype_declaration << (((ABSTRACT + SUPERTYPE + Optional(subtype_constraint)))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="abstract_supertype_declaration")) + inverse_clause << (((INVERSE + inverse_attr + ZeroOrMore(inverse_attr)))).setParseAction(AttributeList) + index_qualifier << (((CaselessLiteral("[") + index_1 + Optional((CaselessLiteral(":") + index_2)) + CaselessLiteral("]")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="index_qualifier")) + bound_1 << (numeric_expression) + compound_stmt << (((BEGIN + stmt + ZeroOrMore(stmt) + END + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="compound_stmt")) + set_type << (((SET + Optional(bound_spec) + OF + instantiable_type))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="set_type")) + where_clause << (((WHERE + domain_rule + CaselessLiteral(";") + ZeroOrMore((domain_rule + CaselessLiteral(";")))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="where_clause")) + qualifier << (((attribute_qualifier | group_qualifier | index_qualifier))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="qualifier")) + entity_head << (((ENTITY + entity_id + subsuper + CaselessLiteral(";")))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="entity_head")) + stmt << (((alias_stmt | assignment_stmt | case_stmt | compound_stmt | escape_stmt | if_stmt | null_stmt | procedure_call_stmt | repeat_stmt | return_stmt | skip_stmt))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="stmt")) + index_2 << (index) + term << (((factor + ZeroOrMore((multiplication_like_op + factor))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="term")) + function_call << ((((built_in_function | function_ref) + actual_parameter_list))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="function_call")) + formal_parameter << (((parameter_id + ZeroOrMore((CaselessLiteral(",") + parameter_id)) + CaselessLiteral(":") + parameter_type))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="formal_parameter")) + simple_expression << (((term + ZeroOrMore((add_like_op + term))))).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="simple_expression")) + simple_types << (((binary_type | boolean_type | integer_type | logical_type | number_type | real_type | string_type))).setParseAction(SimpleType) syntax.ignore("--" + restOfLine) syntax.ignore(Regex(r"\((?:\*(?:[^*]*\*+)+?\))")) @@ -1484,13 +478,12 @@ def parse(fn): with open(cache_file, "wb") as f: pickle.dump(m, f, protocol=0) return m - - + if __name__ == "__main__": m = parse(sys.argv[1]) import importlib - for output in sys.argv[2:]: mdl = importlib.import_module(output) mdl.Generator(m).emit() sys.stdout.write(m.schema.name) + diff --git a/src/ifcopenshell-python/ifcopenshell/express/nodes.py b/src/ifcopenshell-python/ifcopenshell/express/nodes.py index 8b8133f860..412ff49877 100644 --- a/src/ifcopenshell-python/ifcopenshell/express/nodes.py +++ b/src/ifcopenshell-python/ifcopenshell/express/nodes.py @@ -21,6 +21,7 @@ from __future__ import print_function import io import string +import operator import collections @@ -55,6 +56,11 @@ class ListNode: def __init__(self, s, loc, tokens, rule=None): self.rule = rule or (type(self).__name__) self.tokens = tokens.asList() + self.dict_tokens = collections.defaultdict(list) + for t in self.tokens: + r = getattr(t, 'rule', None) + if r: + self.dict_tokens[r].append(t) self.flat = sum([getattr(t, "flat", [t]) for t in self.tokens], []) def __repr__(self): @@ -97,7 +103,7 @@ def format_clause(exp): return "".join(whitespace(term) for term in exp.flat) -class TypeDeclaration(Node): +class TypeDeclaration(Node): name = property(lambda self: self.type_id[0]) utype = property(lambda self: self.underlying_type.any().any()) type = property(lambda self: self.utype[0] if isinstance(self.utype, list) else self.utype) @@ -229,6 +235,41 @@ class NamedType(Node): return self.type +def do_try(fn): + try: + return fn() + except: pass + + +def to_tree(x, key=None): + def get_rule_id(x): + from bootstrap import actions + ty = type(x).__name__ + matches = [k for k, v in actions.items() if v == ty] + if matches: + return matches[0] + + def prune(di): + import bootstrap + rule_dependencies = { + k: list(map(operator.attrgetter('contents'), bootstrap.reduce(lambda x, y: x | y, (bootstrap.find_bytype(e, bootstrap.Keyword) for e in [v])))) \ + for k, v in bootstrap.express + } + subrules = list(filter(str.islower, rule_dependencies[key])) + return {k: v for k, v in di.items() if k in subrules} + + if isinstance(x, ListNode): + return to_tree(x.dict_tokens, key=get_rule_id(x) or key) + if isinstance(x, Node,): + return to_tree(x.tokens, key=get_rule_id(x) or key) + elif isinstance(x, dict): + return prune({k: to_tree(v, key=k) for k, v in x.items()}) + elif isinstance(x, list): + return [to_tree(v, key=key) for v in x] + else: + return x + + class AggregationType(Node): aggregate_type = property(lambda self: self.flat[0]) bounds = property(lambda self: (list(self.tokens.values())[0][0].bound_spec or [None])[0]) @@ -247,6 +288,8 @@ class AggregationType(Node): return v.parameter_type.named_types elif v.parameter_type.generalized_types.general_aggregation_types: return v.parameter_type.generalized_types.general_aggregation_types + elif do_try(lambda: v.parameter_type.generalized_types.generic_type.generic_type[0].GENERIC): + return do_try(lambda: v.parameter_type.generalized_types.generic_type.generic_type[0].GENERIC) else: import pdb diff --git a/src/ifcopenshell-python/ifcopenshell/express/schema.py b/src/ifcopenshell-python/ifcopenshell/express/schema.py index d22f652661..ed217d3123 100644 --- a/src/ifcopenshell-python/ifcopenshell/express/schema.py +++ b/src/ifcopenshell-python/ifcopenshell/express/schema.py @@ -84,6 +84,7 @@ class Schema: return self.types_entities[key] def __init__(self, parsetree): + self.tree = parsetree self.name = parsetree.syntax[0][0].simple_id sort = lambda d: OrderedCaseInsensitiveDict(sorted(d))