Merge pull request #2 from IfcOpenShell/v0.6.0

merge
2026-08-13 10:57:49 +00:00 · 2020-12-21 11:13:59 +08:00
parent ac632d0698 1a48343bcb
commit d7034c6a40
17 changed files with 1065 additions and 134 deletions
@@ -0,0 +1,22 @@
+From a0deb4ce8b43cf3c8b8c0a4225c6be5296446dbd Mon Sep 17 00:00:00 2001
+From: Adam Eri <adam.eri@blackmirror.media>
+Date: Tue, 3 Sep 2019 23:30:20 +0200
+Subject: [PATCH] Resolves compile error on macOS
+
+Resolves "no member named 'isnan' in namespace 'std'" on macOS
+---
+ GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp b/GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp
+index 1f9a3eef..dd6f5c59 100644
+--- a/GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp
+++ b/GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp
+@@ -10,6 +10,7 @@
+ 
+ #include "GeneratedSaxParserUtils.h"
+ #include <math.h>
+#include <cmath>
+ #include <memory>
+ #include <string.h>
+ #include <limits>
@@ -0,0 +1,3 @@
+# Dependency and build folders created by the build scripts
+/build/
+/dist/
@@ -3,5 +3,6 @@ from behave.model import Scenario

 def before_all(context):
    userdata = context.config.userdata
-    continue_after_failed = True
+    context.localedir = userdata.get("localedir")
+    continue_after_failed = userdata.getbool("runner.continue_after_failed_step", True)
    Scenario.continue_after_failed_step = continue_after_failed
@@ -0,0 +1,119 @@
+from behave import step, given, when, then, use_step_matcher
+
+from utils import IfcFile
+
+use_step_matcher("parse")
+@step(u"There must be exactly {number} {ifc_class} element")
+@step(u"There must be exactly {number} {ifc_class} elements")
+def step_impl(context, number, ifc_class):
+    num = len(IfcFile.get().by_type(ifc_class))
+    assert num == int(number), "Could not find {} elements of {}. Found {} element(s).".format(number, ifc_class, num)
+
+@given(u'a set of specific related elements')
+def step_impl(context):
+    model = getattr(context, "model", None)
+    if not model:
+        context.model = TableModel()
+    for row in context.table:
+        context.model.add_row(row["RelatedObjects"], row["RelatingGroup"])
+
+@given(u'a set of specific related elements taken from the file "{path_file}"')
+def step_impl(context, path_file):
+    import csv
+    import os
+    model = getattr(context, "model", None)
+    if not model:
+        context.model = TableModel()
+    if context.config.userdata.get('path'):
+        path_file = os.path.join(context.config.userdata.get('path'), path_file)
+    if not os.path.exists(path_file):
+        assert False, "File {} not found".format(path_file)
+    with open(path_file, 'r', encoding="utf-8-sig") as csvfile:
+        reader = csv.DictReader(csvfile)
+        for row in reader:
+            context.model.add_row(row["RelatedObjects"], row["RelatingGroup"])
+
+@then(u'there must be exactly a number of {ifc_class} equals to the number of distinct row value')
+def step_impl(context, ifc_class):
+    try:
+        context.execute_steps(u"""
+            then There must be exactly {number} {ifc_class} elements
+            """.format(ifc_class=ifc_class, number=context.model.get_count_distinct_values()))
+    except AssertionError as error:
+        str_error = str(error)
+        assert False, str_error[:str_error.find("Traceback")]
+    assert True
+
+@then(u'there is a relationship {ifc_class} with {left_attribute} and {right_attribute} between the two elements of each row')
+def step_impl(context, ifc_class, left_attribute, right_attribute):
+    rows = context.model.rows
+    elements = IfcFile.by_type(ifc_class)
+    errors = []
+    for key, value in rows.items():
+        found = False
+        for element in elements:
+            if any(x.Name == key for x in getattr(element, left_attribute))\
+                and getattr(element, right_attribute).Name == value:
+                found = True
+        if not found:
+            errors.append(f'The row ({key}, {value}) does not have the relationship.')
+    assert not errors, "Errors occured:\n{}".format("\n".join(errors))
+
+use_step_matcher("re")
+@step("all IfcGroup must be linked to a type in the list (?P<linked_ifc_classes>.*)")
+def step_impl(context, linked_ifc_classes):
+    groups = IfcFile.by_type("IfcGroup")
+    errors = []
+    for group in groups:
+        if not hasattr(group, "IsGroupedBy"):
+            errors.append(f'The element "{group.Name}" has no "IsGroupedBy" attribute.')
+        else:
+            for grouped_by in getattr(group, "IsGroupedBy"):
+                if not hasattr(grouped_by, "RelatedObjects"):
+                    errors.append(f'The element "{grouped_by.Name}" has no "RelatedObjects" attribute.')
+                else:
+                    for related_object in getattr(grouped_by, "RelatedObjects"):
+                        found = False
+                        for linked_ifc_class in linked_ifc_classes.split(","):
+                            if(related_object.is_a(linked_ifc_class)):
+                                found = True
+                        if not found:
+                            errors.append(f'The element "{related_object.Name}" does not have the right associated type.') 
+    assert not errors, "Errors occured:\n{}".format("\n".join(errors))
+
+@then(u'there is an element of type (?P<ifc_types>.*) with a (?P<attribute_name>.*) attribute for each row key')
+def step_impl(context, ifc_types, attribute_name):
+    check_if_element_exists_by_types_with_attribute_name(ifc_types, attribute_name, context.model.rows.keys())
+
+@then(u'there is an element of type (?P<ifc_types>.*) with a (?P<attribute_name>.*) attribute for each row value')
+def step_impl(context, ifc_types, attribute_name):
+    values = set(context.model.rows.values())
+    check_if_element_exists_by_types_with_attribute_name(ifc_types, attribute_name, values)
+
+def check_if_element_exists_by_types_with_attribute_name(ifc_types, attribute_name, attribute_values):
+    errors = []
+    # retrieve all elements of that type
+    elements = IfcFile.by_types(ifc_types)
+    # loop
+    for attribute_value in attribute_values:
+        found = False
+        for element in elements:
+            if hasattr(element, attribute_name) and getattr(element, attribute_name) == attribute_value:
+                found = True
+        if not found:
+            errors.append(f'An element with {attribute_name} attribute "{attribute_value}" was not found.')
+    assert not errors, "Errors occured:\n{}".format("\n".join(errors))
+
+class TableModel(object):
+    """This class represents a table of data."""
+    def __init__(self):
+        self.rows = dict()
+
+    def add_row(self, related, relating):
+        self.rows[related] = relating
+        
+    def get_count(self):
+        return len(self.rows)
+    
+    def get_count_distinct_values(self):
+        return len(set(self.rows.values()))
@@ -1,10 +1,19 @@
 import gettext
-from behave import step
+import os
+from behave import step, given

 from ifcdata_methods import assert_schema
 from utils import IfcFile
 from utils import switch_locale

+@step('The IFC schema "{schema}" must be provided')
+def step_impl(context, schema):
+    try:
+        if context.config.userdata.get('path'):
+            schema = os.path.join(context.config.userdata.get('path'), schema)
+        IfcFile.load_schema(schema)
+    except:
+        assert False, f"The schema {schema} could not be loaded"

@step('The IFC file "{file}" must be provided')
 def step_impl(context, file):
@@ -13,6 +22,19 @@ def step_impl(context, file):
    except:
        assert False, f"The file {file} could not be loaded"

+@given('The IFC file has been provided through an argument')
+def step_impl(context):
+    try:
+        IfcFile.load(context.config.userdata.get("ifcfile"))
+    except:
+        assert False, f"The IFC {context.config.userdata.get('ifcfile')} file could not be loaded"
+
+@given('A file path has been provided through an argument')
+def step_impl(context):
+    try:
+        assert context.config.userdata.get("path")
+    except:
+        assert False, f"The path {context.config.userdata.get('path')} could not be loaded"

@step("IFC data must use the {schema} schema")
 def step_impl(context, schema):
@@ -1,4 +1,5 @@
 import ifcopenshell
+import ifcopenshell.express
 import ifcopenshell.util
 import ifcopenshell.util.element

@@ -10,6 +11,13 @@ class IfcFile(object):
    @classmethod
    def load(cls, path=None):
        cls.file = ifcopenshell.open(path)
+        if not cls.file:
+            assert False
+    
+    @classmethod
+    def load_schema(cls, path=None):
+        schema = ifcopenshell.express.parse(path)
+        ifcopenshell.register_schema(schema)

    @classmethod
    def get(cls):
@@ -23,6 +31,17 @@ class IfcFile(object):
            return cls.get().by_guid(guid)
        except:
            assert False, "An element with the ID {} could not be found.".format(guid)
+    
+    @classmethod
+    def by_type(cls, ifc_type):
+        return cls.get().by_type(ifc_type.strip())
+
+    @classmethod
+    def by_types(cls, ifc_types):
+        elements = []
+        for ifc_type in ifc_types.split(","):
+            elements += cls.by_type(ifc_type.strip())
+        return elements


 def assert_number(number):
@@ -7,18 +7,20 @@
    <title>{{name}}</title>
    <link href="https://fonts.googleapis.com/css?family=Comfortaa|Inconsolata|Open+Sans&display=swap" rel="stylesheet">
    <style>
-        body { font-family: 'Arial', sans-serif; padding: 40px; }
+        body { font-family: 'Arial', sans-serif; padding: 10px 40px; }
        span.time { color: #999; font-style: italic; float: right; }
        span.step-time { float: right; color: #555; font-size: 0.8em; font-style: italic; }
        span.success { background-color: #97cc64; padding: 5px; border-radius: 5px; color: #FFF; font-weight: bold; }
        span.failure { background-color: #fb5a3e; padding: 5px; border-radius: 5px; color: #FFF; font-weight: bold; }
        p.failure { background-color: #fb5a3e; padding: 5px; border-radius: 5px; color: #fff; }
        p.unspecified { background-color: #994f00; padding: 5px; border-radius: 5px; color: #fff; }
+        p.skipped { background-color: #8b8d8f; padding: 5px; border-radius: 5px; color: #fff; }
        p.description { background-color: #eee; border-radius: 5px; padding: 20px; margin-left: auto; margin-right: auto; display: inline-block; font-weight: bold;}
        li { padding: 10px; font-family: monospace; }
        li.success { background-color: #b6cca1; color: #333; }
        li.failure { background-color: #fbb4a8; color: #900; }
        li.unspecified { background-color: #ffd37f; color: #a30; }
+        li.skipped { background-color: #f5f5f5; color: #333; }
        li p { margin-bottom: 0px; }
        footer { color: #999; font-size: 0.8em; }
        header { text-align: center; }
@@ -52,11 +54,11 @@
        </p>
        <ol>
            {{#steps}}
-            <li class="{{#is_success}}success{{/is_success}}{{^is_success}}failure{{/is_success}}{{#is_unspecified}} unspecified{{/is_unspecified}}">
+            <li class="{{#is_success}}success{{/is_success}}{{^is_success}}failure{{/is_success}}{{#is_unspecified}} unspecified{{/is_unspecified}}{{#is_skipped}} skipped{{/is_skipped}}">
                {{{name}}}
                <span class="step-time">{{time}}s</span>
                {{^is_success}}
-                <p class="failure{{#is_unspecified}} unspecified{{/is_unspecified}}">
+                <p class="failure{{#is_unspecified}} unspecified{{/is_unspecified}}{{#is_skipped}} skipped{{/is_skipped}}">
                    {{#error_message}}
                    {{.}}<br />
                    {{/error_message}}
@@ -4,8 +4,8 @@ import os
 import pystache


-def generate_report(adir="."):
-    print("# Generating HTML reports now.")
+def generate_report(adir=".", use_report_folder=True, report_file_name="", html_template_file_path=""):
+    #print("# Generating HTML reports now.")

    # get html template path
    report_template_path = os.path.join(
@@ -13,11 +13,20 @@ def generate_report(adir="."):
        "features/"
    )

+    if html_template_file_path:
+        report_template_path = html_template_file_path
+
    # get report file
-    report_dir = os.path.join(adir, "report")
+    report_dir = adir
+    if use_report_folder:
+        report_dir = os.path.join(adir, "report")
    if not os.path.exists(report_dir):
        return print("No report directory was found.")
-    report_path = os.path.join(report_dir, "report.json")
+
+    if report_file_name:
+      report_path = os.path.join(report_dir, report_file_name)
+    else:
+      report_path = os.path.join(report_dir, "report.json")
    # print(report_path)
    if not os.path.exists(report_path):
        return print("No report data was found.")
@@ -58,7 +67,12 @@ def generate_report(adir="."):
                if "match" in step and "arguments" in step["match"]:
                    for a in step["match"]["arguments"]:
                        name = name.replace(a["value"], "<b>" + a["value"] + "</b>")
-                if "result" not in step or step["result"]["status"] == "undefined":
+                if "result" not in step:
+                    step["result"] = {}
+                    step["result"]["status"] = "skipped"
+                    step["result"]["duration"] = 0
+                    step["result"]["error_message"] = "This requirement has been skipped due to a previous failing step."
+                elif step["result"]["status"] == "undefined":
                    step["result"] = {}
                    step["result"]["status"] = "undefined"
                    step["result"]["duration"] = 0
@@ -68,7 +82,8 @@ def generate_report(adir="."):
                        "name": name,
                        "time": round(step["result"]["duration"], 2),
                        "is_success": step["result"]["status"] == "passed",
-                        "is_unspecified": "result" not in step or step["result"]["status"] == "undefined",
+                        "is_unspecified": step["result"]["status"] == "undefined",
+                        "is_skipped": step["result"]["status"] == "skipped",
                        "error_message": None
                        if step["result"]["status"] == "passed"
                        else step["result"]["error_message"],
@@ -43,6 +43,10 @@ def run_tests(args):
        "--define",
        "localedir={}".format(locale_path)
    ])
+    if args["ifcfile"]:
+        behave_args.extend(["--define", "ifcfile={}".format(args["ifcfile"])])
+    if args["path"]:
+        behave_args.extend(["--define", "path={}".format(args["path"])])
    behave_main(behave_args)
    print("# All tests are finished.")
    return True
@@ -42,6 +42,21 @@ if __name__ == "__main__":
        action="store_true",
        help="Generate a HTML report"
    )
+    parser.add_argument(
+        "-rr",
+        "--report_after_run",
+        action="store_true",
+        help="Generate a HTML report after running the tests"
+    )
+    parser.add_argument(
+        "-path",
+        "--path",
+        type=str,
+        help=(
+            "Specify a path to prepend to feature and ifc file"
+        ),
+        default=""
+    )
    parser.add_argument(
        "-c",
        "--console",
@@ -95,6 +110,12 @@ if __name__ == "__main__":
    args = vars(parser.parse_args())
    print(args)

+    if args["path"]:
+        if args["feature"]:
+            args["feature"] = os.path.join(args["path"], args["feature"])
+        if not args["gui"]:
+            args["ifcfile"] = os.path.join(args["path"], args["ifcfile"])
+
    if args["purge"]:
        clean.TestPurger().purge()
    elif args["report"]:
@@ -103,4 +124,6 @@ if __name__ == "__main__":
        show_widget(args["featuresdir"], args["ifcfile"])
    else:
        run.run_tests(args)
+        if args["report_after_run"]:
+            reports.generate_report()
    print("# All tasks are complete :-)")
@@ -28,6 +28,11 @@ if bpy is not None:
        operator.NewBcfProject,
        operator.LoadBcfProject,
        operator.LoadBcfTopics,
+        operator.LoadBcfComments,
+        operator.EditBcfProjectName,
+        operator.EditBcfAuthor,
+        operator.EditBcfTopicName,
+        operator.EditBcfTopic,
        operator.SaveBcfProject,
        operator.AddBcfTopic,
        operator.ViewBcfTopic,
@@ -44,6 +49,7 @@ if bpy is not None:
        operator.ValidateIfcFile,
        operator.ExportIFC,
        operator.ImportIFC,
+        operator.ProfileImportIFC,
        operator.ColourByClass,
        operator.ColourByAttribute,
        operator.ColourByPset,
@@ -260,6 +266,7 @@ if bpy is not None:
        prop.Sheet,
        prop.BcfBimSnippet,
        prop.BcfDocumentReference,
+        prop.BcfComment,
        prop.BcfTopic,
        prop.Subcontext,
        prop.PresentationLayer,
@@ -295,6 +302,8 @@ if bpy is not None:
        ui.BIM_PT_ifccsv,
        ui.BIM_PT_ifcclash,
        ui.BIM_PT_bcf,
+        ui.BIM_PT_bcf_metadata,
+        ui.BIM_PT_bcf_comments,
        ui.BIM_PT_owner,
        ui.BIM_PT_people,
        ui.BIM_PT_organisations,
@@ -38,7 +38,7 @@ class MaterialCreator:
    def __init__(self, ifc_import_settings, ifc_importer):
        self.mesh = None
        self.materials = {}
-        self.parsed_meshes = []
+        self.parsed_meshes = set()
        self.ifc_import_settings = ifc_import_settings
        self.ifc_importer = ifc_importer

@@ -54,7 +54,7 @@ class MaterialCreator:
            return
        if self.mesh.name in self.parsed_meshes:
            return
-        self.parsed_meshes.append(self.mesh.name)
+        self.parsed_meshes.add(self.mesh.name)
        if self.parse_representations(element):
            self.assign_material_slots_to_faces(obj)

@@ -85,8 +85,11 @@ class MaterialCreator:
        item_id = self.mesh.BIMMeshProperties.ifc_item_ids.add()
        item_id.name = str(item.id())

-        styled_item = item.StyledByItem[0]
-        style_name = self.get_style_name(styled_item)
+        styled_item = item.StyledByItem[0] # Cardinality is S[0:1]
+        style_name = self.get_surface_style_name(styled_item)
+
+        if not style_name:
+            return

        if self.mesh.materials.get(style_name):
            item_id.slot_index = self.mesh.materials.find(style_name)
@@ -266,7 +269,7 @@ class MaterialCreator:
                    continue
                self.parse_styled_item(item, obj)

-    def get_style_name(self, styled_item):
+    def get_surface_style_name(self, styled_item):
        if styled_item.Name:
            return styled_item.Name
        styles = self.get_styled_item_styles(styled_item)
@@ -276,7 +279,7 @@ class MaterialCreator:
            if style.Name:
                return style.Name
            return str(style.id())
-        return str(styled_item.id())
+        return None # We only support surface styles right now

    def parse_styled_item(self, styled_item, material):
        styles = self.get_styled_item_styles(styled_item)
@@ -465,10 +468,10 @@ class IfcImporter:
        ):
            self.merge_materials_by_colour()
            self.profile_code("Merging by colour")
-        self.add_project_to_scene()
-        self.profile_code("Add project to scene")
        self.create_presentation_layers()
        self.profile_code("Create presentation layers")
+        self.add_project_to_scene()
+        self.profile_code("Add project to scene")
        if self.ifc_import_settings.should_clean_mesh and len(self.file.by_type("IfcElement")) < 10000:
            self.clean_mesh()
            self.profile_code("Mesh cleaning")
@@ -1098,7 +1101,7 @@ class IfcImporter:
        if not item.StyledByItem:
            return
        styled_item = item.StyledByItem[0]
-        return self.material_creator.get_style_name(styled_item)
+        return self.material_creator.get_surface_style_name(styled_item)

    def transform_curve(self, curve, matrix):
        for spline in curve.splines:
@@ -1305,18 +1308,10 @@ class IfcImporter:
        except:
            # Occurs when reloading a project
            pass
-        for collection in (
-            bpy.context.view_layer.layer_collection.children[self.project["blender"].name]
-            .children[self.aggregate_collection.name]
-            .children
-        ):
-            collection.hide_viewport = True
-        bpy.context.view_layer.layer_collection.children[self.project["blender"].name].children[
-            self.opening_collection.name
-        ].hide_viewport = True
-        bpy.context.view_layer.layer_collection.children[self.project["blender"].name].children[
-            self.type_collection.name
-        ].hide_viewport = True
+        project_collection = bpy.context.view_layer.layer_collection.children[self.project["blender"].name]
+        project_collection.children[self.aggregate_collection.name].hide_viewport = True
+        project_collection.children[self.opening_collection.name].hide_viewport = True
+        project_collection.children[self.type_collection.name].hide_viewport = True

    def create_presentation_layers(self):
        for assignment in self.file.by_type("IfcPresentationLayerAssignment"):
@@ -1333,19 +1328,15 @@ class IfcImporter:
            for item in assignment.AssignedItems:
                # TODO: This is a simplified implementation of assigning presentation layers that ignores assigned
                # representation items, does not consider mapped representations, and assumes a Body context. See #1109.
-                guids = []
                if not hasattr(item, "OfProductRepresentation") or item.RepresentationIdentifier != "Body":
                    continue
                for product_representation in item.OfProductRepresentation:
                    for product in product_representation.ShapeOfProduct:
-                        guids.append(product.GlobalId)
-                for obj in bpy.context.selectable_objects:
-                    global_id = obj.BIMObjectProperties.attributes.get("GlobalId")
-                    if global_id and global_id.string_value in guids:
-                        if not obj.data or not hasattr(obj.data, "BIMMeshProperties"):
-                            continue
-                        obj.data.BIMMeshProperties.presentation_layer_index = layer_index
-                        obj.hide_set(not layer.layer_on)
+                        try:
+                            obj = self.added_data[product.GlobalId]
+                            obj.data.BIMMeshProperties.presentation_layer_index = layer_index
+                        except:
+                            pass # Occurs for example in opening elements or exclusions

    def clean_mesh(self):
        obj = None
@@ -138,6 +138,19 @@ class ImportIFC(bpy.types.Operator, ImportHelper):
        return {"FINISHED"}


+class ProfileImportIFC(bpy.types.Operator):
+    bl_idname = "bim.profile_import_ifc"
+    bl_label = "Profile Import IFC"
+
+    def execute(self, context):
+        import cProfile
+        import pstats
+        cProfile.run(f"import bpy; bpy.ops.import_ifc.bim(filepath='{bpy.context.scene.BIMProperties.ifc_file}')", "blender.prof")
+        p = pstats.Stats("blender.prof")
+        p.sort_stats("cumulative").print_stats(50)
+        return {"FINISHED"}
+
+
 class SelectGlobalId(bpy.types.Operator):
    bl_idname = "bim.select_global_id"
    bl_label = "Select GlobalId"
@@ -527,7 +540,6 @@ class LoadBcfProject(bpy.types.Operator):
        bcfxml = bcfstore.BcfStore.get_bcfxml()
        if self.filepath:
            bcfxml.get_project(self.filepath)
-        bpy.context.scene.BCFProperties.is_editable = False
        bpy.context.scene.BCFProperties.name = bcfxml.project.name
        bpy.ops.bim.load_bcf_topics()
        bpy.context.scene.BCFProperties.is_loaded = True
@@ -550,8 +562,8 @@ class LoadBcfTopics(bpy.types.Operator):
        for topic in bcfxml.topics.values():
            new = bpy.context.scene.BCFProperties.topics.add()
            data_map = {
-                "name": topic.title,
-                "guid": topic.guid,
+                "name": topic.guid,
+                "title": topic.title,
                "type": topic.topic_type,
                "status": topic.topic_status,
                "priority": topic.priority,
@@ -597,6 +609,91 @@ class LoadBcfTopics(bpy.types.Operator):
            for related_topic in topic.related_topics:
                new2 = new.related_topics.add()
                new2.name = related_topic.guid
+            bpy.ops.bim.load_bcf_comments(topic_guid = topic.guid)
+        return {"FINISHED"}
+
+
+class LoadBcfComments(bpy.types.Operator):
+    bl_idname = "bim.load_bcf_comments"
+    bl_label = "Load BCF Comments"
+    topic_guid: bpy.props.StringProperty()
+
+    def execute(self, context):
+        bcfxml = bcfstore.BcfStore.get_bcfxml()
+        bcfxml.get_comments(self.topic_guid)
+        blender_topic = bpy.context.scene.BCFProperties.topics.get(self.topic_guid)
+        for comment in bcfxml.topics[self.topic_guid].comments.values():
+            new = blender_topic.comments.add()
+            data_map = {
+                "name": comment.guid,
+                "comment": comment.comment,
+                "viewpoint": comment.viewpoint.guid if comment.viewpoint else None,
+                "date": comment.date,
+                "author": comment.author,
+                "modified_date": comment.modified_date,
+                "modified_author": comment.modified_author,
+            }
+            for key, value in data_map.items():
+                if value is not None:
+                    setattr(new, key, str(value))
+        return {"FINISHED"}
+
+
+class EditBcfProjectName(bpy.types.Operator):
+    bl_idname = "bim.edit_bcf_project_name"
+    bl_label = "Edit BCF Project Name"
+
+    def execute(self, context):
+        bcfxml = bcfstore.BcfStore.get_bcfxml()
+        bcfxml.project.name = bpy.context.scene.BCFProperties.name
+        bcfxml.edit_project()
+        return {"FINISHED"}
+
+
+class EditBcfAuthor(bpy.types.Operator):
+    bl_idname = "bim.edit_bcf_author"
+    bl_label = "Edit BCF Author"
+
+    def execute(self, context):
+        bcfxml = bcfstore.BcfStore.get_bcfxml()
+        bcfxml.author = bpy.context.scene.BCFProperties.author
+        return {"FINISHED"}
+
+
+class EditBcfTopicName(bpy.types.Operator):
+    bl_idname = "bim.edit_bcf_topic_name"
+    bl_label = "Edit BCF Topic Name"
+
+    def execute(self, context):
+        props = bpy.context.scene.BCFProperties
+        blender_topic = props.topics[props.active_topic_index]
+        bcfxml = bcfstore.BcfStore.get_bcfxml()
+        topic = bcfxml.topics[blender_topic.name]
+        topic.title = blender_topic.title
+        bcfxml.edit_topic(topic)
+        return {"FINISHED"}
+
+
+class EditBcfTopic(bpy.types.Operator):
+    bl_idname = "bim.edit_bcf_topic"
+    bl_label = "Edit BCF Topic"
+
+    def execute(self, context):
+        props = bpy.context.scene.BCFProperties
+        blender_topic = props.topics[props.active_topic_index]
+        bcfxml = bcfstore.BcfStore.get_bcfxml()
+
+        topic = bcfxml.topics[blender_topic.name]
+        topic.title = blender_topic.title or None
+        topic.priority = blender_topic.priority or None
+        topic.due_date = blender_topic.due_date or None
+        topic.assigned_to = blender_topic.assigned_to or None
+        topic.stage = blender_topic.stage or None
+        topic.description = blender_topic.description or None
+        topic.topic_status = blender_topic.status or None
+        topic.topic_type = blender_topic.type or None
+
+        bcfxml.edit_topic(topic)
        return {"FINISHED"}


@@ -2168,7 +2265,6 @@ class CreateAggregate(bpy.types.Operator):
                project.collection.children.link(aggregates)
            for aggregate_collection in [c for c in project.children if "Aggregates" in c.name]:
                aggregate_collection.collection.children.link(aggregate)
-                aggregate_collection.children[aggregate.name].hide_viewport = True
                break
            break
        for obj in bpy.context.selected_objects:
@@ -2199,9 +2295,7 @@ class EditAggregate(bpy.types.Operator):
        bpy.context.view_layer.objects[obj.name].hide_viewport = True
        for project in [c for c in bpy.context.view_layer.layer_collection.children if "IfcProject" in c.name]:
            for aggregate_collection in [c for c in project.children if "Aggregates" in c.name]:
-                for aggregate in [c for c in aggregate_collection.children if c.name == obj.instance_collection.name]:
-                    aggregate.hide_viewport = False
-                    break
+                aggregate_collection.hide_viewport = False
        return {"FINISHED"}


@@ -2215,8 +2309,8 @@ class SaveAggregate(bpy.types.Operator):
        names = [c.name for c in obj.users_collection]
        for project in [c for c in bpy.context.view_layer.layer_collection.children if "IfcProject" in c.name]:
            for aggregate_collection in [c for c in project.children if "Aggregates" in c.name]:
+                aggregate_collection.hide_viewport = True
                for collection in [c for c in aggregate_collection.children if c.name in names]:
-                    collection.hide_viewport = True
                    aggregate = collection.collection
                    break
        if not aggregate:
@@ -540,6 +540,35 @@ def refreshFontSize(self, context):
    annotation.Annotator.resize_text(context.active_object)


+def updateBcfProjectName(self, context):
+    bpy.ops.bim.edit_bcf_project_name()
+
+
+def updateBcfAuthor(self, context):
+    bpy.ops.bim.edit_bcf_author()
+
+
+def updateBcfTopicName(self, context):
+    bpy.ops.bim.edit_bcf_topic_name()
+
+
+def updateBcfTopicIsEditable(self, context):
+    if not self.is_editable:
+        print("EDITING!")
+        bpy.ops.bim.edit_bcf_topic()
+
+
+def refreshBcfTopic(self, context):
+    global bcfviewpoints_enum
+    bcfviewpoints_enum = None
+
+    props = bpy.context.scene.BCFProperties
+    bcfxml = bcfstore.BcfStore.get_bcfxml()
+    topic = props.topics[props.active_topic_index]
+    header = bcfxml.get_header(topic.name)
+    getBcfViewpoints(self, context)
+
+
 class StrProperty(PropertyGroup):
    pass

@@ -917,7 +946,7 @@ def getBcfViewpoints(self, context):
        props = bpy.context.scene.BCFProperties
        bcfxml = bcfstore.BcfStore.get_bcfxml()
        topic = props.topics[props.active_topic_index]
-        viewpoints = bcfxml.get_viewpoints(topic.guid)
+        viewpoints = bcfxml.get_viewpoints(topic.name)
        bcfviewpoints_enum.extend([(v, f"Viewpoint {i+1}", "") for i, v in enumerate(viewpoints.keys())])
    return bcfviewpoints_enum

@@ -936,9 +965,19 @@ class BcfDocumentReference(PropertyGroup):
    is_external: BoolProperty(name="Is External")


+class BcfComment(PropertyGroup):
+    name: StringProperty(name="GUID")
+    date: StringProperty(name="Date")
+    author: StringProperty(name="Author")
+    comment: StringProperty(name="Comment")
+    viewpoint: StringProperty(name="Viewpoint")
+    modified_date: StringProperty(name="Modified Date")
+    modified_author: StringProperty(name="Modified Author")
+
+
 class BcfTopic(PropertyGroup):
-    name: StringProperty(name="Name")
-    guid: StringProperty(default="", name="GUID")
+    name: StringProperty(name="GUID")
+    title: StringProperty(default="", name="Title", update=updateBcfTopicName)
    type: StringProperty(default="", name="Type")
    status: StringProperty(default="", name="Status")
    priority: StringProperty(default="", name="Priority")
@@ -957,17 +996,8 @@ class BcfTopic(PropertyGroup):
    bim_snippet: PointerProperty(type=BcfBimSnippet)
    document_references: CollectionProperty(name="Document References", type=BcfDocumentReference)
    related_topics: CollectionProperty(name="Related Topics", type=StrProperty)
-
-
-def refreshBcfTopic(self, context):
-    global bcfviewpoints_enum
-    bcfviewpoints_enum = None
-
-    props = bpy.context.scene.BCFProperties
-    bcfxml = bcfstore.BcfStore.get_bcfxml()
-    topic = props.topics[props.active_topic_index]
-    header = bcfxml.get_header(topic.guid)
-    getBcfViewpoints(self, context)
+    comments: CollectionProperty(name="Comments", type=BcfComment)
+    is_editable: BoolProperty(name="Is Editable", default=False, update=updateBcfTopicIsEditable)


 class PropertySetTemplate(PropertyGroup):
@@ -1476,10 +1506,10 @@ class BIMProperties(PropertyGroup):


 class BCFProperties(PropertyGroup):
-    is_editable: BoolProperty(name="Is Editable", default=False)
    is_loaded: BoolProperty(name="Is Loaded", default=False)
-    name: StringProperty(default="", name="Project Name")
-    author: StringProperty(default="john@doe.com", name="Author Email")
+    comment_text_width: IntProperty(name="Comment Text Width", default=40)
+    name: StringProperty(default="", name="Project Name", update=updateBcfProjectName)
+    author: StringProperty(default="john@doe.com", name="Author Email", update=updateBcfAuthor)
    topics: CollectionProperty(name="BCF Topics", type=BcfTopic)
    active_topic_index: IntProperty(name="Active BCF Topic Index", update=refreshBcfTopic)

@@ -1658,6 +1658,7 @@ class BIM_PT_bcf(Panel):
    def draw(self, context):
        layout = self.layout
        layout.use_property_split = True
+        layout.use_property_decorate = False

        scene = context.scene
        props = bpy.context.scene.BCFProperties
@@ -1682,10 +1683,14 @@ class BIM_PT_bcf(Panel):
        row.template_list("BIM_UL_topics", "", props, "topics", props, "active_topic_index")
        col = row.column(align=True)
        col.operator("bim.add_bcf_topic", icon="ADD", text="")
+        if props.active_topic_index < len(props.topics):
+            topic = props.topics[props.active_topic_index]
+            col.prop(topic, "is_editable", icon="CHECKMARK" if topic.is_editable else "GREASEPENCIL", icon_only=True)

        if props.active_topic_index < len(props.topics):
            topic = props.topics[props.active_topic_index]
            row = layout.row()
+            row.enabled = topic.is_editable
            row.prop(topic, "description", text="")

            row = layout.row()
@@ -1693,85 +1698,161 @@ class BIM_PT_bcf(Panel):
            row.operator("bim.activate_bcf_viewpoint", icon="SCENE", text="")

            col = layout.column(align=True)
-            col.prop(topic, "type")
-            col.prop(topic, "status")
-            col.prop(topic, "priority")
-            col.prop(topic, "stage")
-            col.prop(topic, "assigned_to")
-            col.prop(topic, "due_date")
+            if topic.type:
+                col.prop(topic, "type", emboss=topic.is_editable)
+            if topic.status:
+                col.prop(topic, "status", emboss=topic.is_editable)
+            if topic.priority:
+                col.prop(topic, "priority", emboss=topic.is_editable)
+            if topic.stage:
+                col.prop(topic, "stage", emboss=topic.is_editable)
+            if topic.assigned_to:
+                col.prop(topic, "assigned_to", emboss=topic.is_editable)
+            if topic.due_date:
+                col.prop(topic, "due_date", emboss=topic.is_editable)

            col = layout.column(align=True)
-            col.enabled = False
-            col.prop(topic, "creation_date")
-            col.prop(topic, "creation_author")
-            col.prop(topic, "modified_date")
-            col.prop(topic, "modified_author")
+            if topic.modified_date:
+                col.prop(topic, "modified_date", emboss=False)
+                col.prop(topic, "modified_author", emboss=False)
+            else:
+                col.prop(topic, "creation_date", emboss=False)
+                col.prop(topic, "creation_author", emboss=False)

-            bcfxml = bcfstore.BcfStore.get_bcfxml()
-            bcf_topic = bcfxml.topics[topic.guid]

-            if bcf_topic.header:
-                layout.label(text="Header Files:")
-                for index, f in enumerate(bcf_topic.header.files):
-                    box = self.layout.box()
-                    row = box.row(align=True)
-                    row.label(text=f.filename, icon="FILE_BLANK")
-                    if f.is_external:
-                        row.operator("bim.open_uri", icon="URL", text="").uri = f.reference
-                    else:
-                        op = row.operator("bim.open_uri", icon="FILE_FOLDER", text="")
-                        op.uri = os.path.join(bcfxml.filepath, topic.guid, f.reference)
-                    box.label(text=f.date)
-                    #box.label(text=f.ifc_project)
-                    #box.label(text=f.ifc_spatial_structure_element)
+class BIM_PT_bcf_metadata(Panel):
+    bl_label = "BCF Metadata"
+    bl_idname = "BIM_PT_bcf_metadata"
+    bl_options = {"DEFAULT_CLOSED"}
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "scene"
+    bl_parent_id = "BIM_PT_bcf"

-            if topic.reference_links:
-                layout.label(text="Reference Links:")
-                for index, link in enumerate(topic.reference_links):
-                    row = layout.row(align=True)
-                    row.prop(link, "name")
-                    row.operator("bim.open_uri", icon="URL", text="").uri = link.name
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False

-            if topic.labels:
-                layout.label(text="Labels:")
-                for index, label in enumerate(topic.labels):
-                    row = layout.row(align=True)
-                    row.prop(label, "name", text="")
+        scene = context.scene
+        props = bpy.context.scene.BCFProperties

-            if topic.bim_snippet.schema:
-                layout.label(text="BIM Snippet:")
-                row = layout.row(align=True)
-                row.prop(topic.bim_snippet, "type")
-                if topic.bim_snippet.schema:
-                    row.operator("bim.open_uri", icon="URL", text="").uri = topic.bim_snippet.schema
+        if props.active_topic_index >= len(props.topics):
+            layout.label(text="No BCF project is loaded")
+            return

-                row = layout.row(align=True)
-                row.prop(topic.bim_snippet, "reference")
-                if topic.bim_snippet.is_external:
-                    row.operator("bim.open_uri", icon="URL", text="").uri = topic.bim_snippet.reference
+        topic = props.topics[props.active_topic_index]
+        bcfxml = bcfstore.BcfStore.get_bcfxml()
+        bcf_topic = bcfxml.topics[topic.name]
+
+        if bcf_topic.header:
+            layout.label(text="Header Files:")
+            for index, f in enumerate(bcf_topic.header.files):
+                box = self.layout.box()
+                row = box.row(align=True)
+                row.label(text=f.filename, icon="FILE_BLANK")
+                if f.is_external:
+                    row.operator("bim.open_uri", icon="URL", text="").uri = f.reference
                else:
                    op = row.operator("bim.open_uri", icon="FILE_FOLDER", text="")
-                    op.uri = os.path.join(bcfxml.filepath, topic.guid, topic.bim_snippet.reference)
+                    op.uri = os.path.join(bcfxml.filepath, topic.name, f.reference)
+                box.label(text=f.date)
+                #box.label(text=f.ifc_project)
+                #box.label(text=f.ifc_spatial_structure_element)

-            if topic.document_references:
-                layout.label(text="Document References:")
-                for index, doc in enumerate(topic.document_references):
-                    box = self.layout.box()
-                    row = box.row(align=True)
-                    row.prop(doc, "reference")
-                    if doc.is_external:
-                        row.operator("bim.open_uri", icon="URL", text="").uri = doc.reference
-                    else:
-                        op = row.operator("bim.open_uri", icon="FILE_FOLDER", text="")
-                        op.uri = os.path.join(bcfxml.filepath, topic.guid, doc.reference)
-                    row = box.row(align=True)
-                    row.prop(doc, "description")
+        if topic.reference_links:
+            layout.label(text="Reference Links:")
+            for index, link in enumerate(topic.reference_links):
+                row = layout.row(align=True)
+                row.prop(link, "name")
+                row.operator("bim.open_uri", icon="URL", text="").uri = link.name

-            if topic.related_topics:
-                layout.label(text="Related Topics:")
-                for related_topic in topic.related_topics:
-                    row = layout.row(align=True)
-                    row.operator("bim.view_bcf_topic", text=related_topic.name).topic_guid = related_topic.name
+        if topic.labels:
+            layout.label(text="Labels:")
+            for index, label in enumerate(topic.labels):
+                row = layout.row(align=True)
+                row.prop(label, "name", text="")
+
+        if topic.bim_snippet.schema:
+            layout.label(text="BIM Snippet:")
+            row = layout.row(align=True)
+            row.prop(topic.bim_snippet, "type")
+            if topic.bim_snippet.schema:
+                row.operator("bim.open_uri", icon="URL", text="").uri = topic.bim_snippet.schema
+
+            row = layout.row(align=True)
+            row.prop(topic.bim_snippet, "reference")
+            if topic.bim_snippet.is_external:
+                row.operator("bim.open_uri", icon="URL", text="").uri = topic.bim_snippet.reference
+            else:
+                op = row.operator("bim.open_uri", icon="FILE_FOLDER", text="")
+                op.uri = os.path.join(bcfxml.filepath, topic.name, topic.bim_snippet.reference)
+
+        if topic.document_references:
+            layout.label(text="Document References:")
+            for index, doc in enumerate(topic.document_references):
+                box = self.layout.box()
+                row = box.row(align=True)
+                row.prop(doc, "reference")
+                if doc.is_external:
+                    row.operator("bim.open_uri", icon="URL", text="").uri = doc.reference
+                else:
+                    op = row.operator("bim.open_uri", icon="FILE_FOLDER", text="")
+                    op.uri = os.path.join(bcfxml.filepath, topic.name, doc.reference)
+                row = box.row(align=True)
+                row.prop(doc, "description")
+
+        if topic.related_topics:
+            layout.label(text="Related Topics:")
+            for related_topic in topic.related_topics:
+                row = layout.row(align=True)
+                row.operator("bim.view_bcf_topic", text=related_topic.name).topic_guid = related_topic.name
+
+
+class BIM_PT_bcf_comments(Panel):
+    bl_label = "BCF Comments"
+    bl_idname = "BIM_PT_bcf_comments"
+    bl_options = {"DEFAULT_CLOSED"}
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "scene"
+    bl_parent_id = "BIM_PT_bcf"
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False
+
+        scene = context.scene
+        props = bpy.context.scene.BCFProperties
+
+        if props.active_topic_index >= len(props.topics):
+            layout.label(text="No BCF project is loaded")
+            return
+
+        row = layout.row()
+        row.prop(props, "comment_text_width")
+
+        topic = props.topics[props.active_topic_index]
+        for comment in topic.comments:
+            box = self.layout.box()
+            box.separator()
+            author_text = "{} ({})".format(comment.author, comment.date)
+            if comment.modified_author:
+                author_text = "*{} ({})".format(comment.modified_author, comment.modified_date)
+            box.label(text=author_text, icon="WORDWRAP_ON")
+            box.separator()
+            box.scale_y = 0.5
+            words = comment.comment.split()
+            while words:
+                total_line_chars = 0
+                line_words = []
+                while words and total_line_chars < props.comment_text_width:
+                    word = words.pop(0)
+                    line_words.append(word)
+                    total_line_chars += len(word) + 1 # 1 is for the space
+                box.label(text=" ".join(line_words))
+            box.separator()


 class BIM_PT_qa(Panel):
@@ -2105,7 +2186,7 @@ class BIM_UL_topics(bpy.types.UIList):
    def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
        ob = data
        if item:
-            layout.prop(item, "name", text="", emboss=False)
+            layout.prop(item, "title", text="", emboss=False)
        else:
            layout.label(text="", translate=False)

@@ -2460,6 +2541,9 @@ class BIM_PT_debug(Panel):
        scene = context.scene
        props = scene.BIMDebugProperties

+        row = layout.row()
+        row.operator("bim.profile_import_ifc")
+
        row = layout.row()
        row.prop(props, "step_id", text="")
        row = layout.row()
@@ -4,6 +4,7 @@
 #include <boost/property_tree/ptree.hpp>

 #include <map>
+#include <mutex>

 namespace pt = boost::property_tree;

@@ -112,6 +113,9 @@ void IfcGeom::set_default_style_file(const std::string& json_file) {
 }

 const IfcGeom::SurfaceStyle* IfcGeom::get_default_style(const std::string& s) {
+	static std::mutex m;
+	std::lock_guard<std::mutex> lk(m);
+
 	if (!default_materials_initialized) InitDefaultMaterials();
 	std::map<std::string, IfcGeom::SurfaceStyle>::const_iterator it = default_materials.find(s);
 	if (it == default_materials.end()) {
@@ -0,0 +1,489 @@
+
+# This file is generated by IfcOpenShell ifcexpressparser bootstrap.py
+
+import os
+import sys
+import pickle
+
+import schema
+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:      
+        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")
+        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")
+        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")
+        ARRAY = (CaselessKeyword("array")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ARRAY"))("ARRAY")
+        AS = (CaselessKeyword("as")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="AS"))("AS")
+        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")
+        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")
+        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")
+        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_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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        NVL = (CaselessKeyword("nvl")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="NVL"))("NVL")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        SELF = (CaselessKeyword("self")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="SELF"))("SELF")
+        SET = (CaselessKeyword("set")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="SET"))("SET")
+        SIN = (CaselessKeyword("sin")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="SIN"))("SIN")
+        SIZEOF = (CaselessKeyword("sizeof")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="SIZEOF"))("SIZEOF")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        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")
+        attribute_ref = (attribute_id)("attribute_ref")
+        constant_ref = (constant_id)("constant_ref")
+        entity_ref = (entity_id)("entity_ref")
+        enumeration_ref = (enumeration_id)("enumeration_ref")
+        function_ref = (function_id)("function_ref")
+        parameter_ref = (parameter_id)("parameter_ref")
+        procedure_ref = (procedure_id)("procedure_ref")
+        rule_label_ref = (rule_label_id)("rule_label_ref")
+        rule_ref = (rule_id)("rule_ref")
+        schema_ref = (schema_id)("schema_ref")
+        subtype_constraint_ref = (subtype_constraint_id)("subtype_constraint_ref")
+        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")
+        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")
+        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")
+        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")
+        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")
+        width = Forward()("width")
+        procedure_call_stmt = Forward()("procedure_call_stmt")
+        interval_high = Forward()("interval_high")
+        expression = Forward()("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"))
+        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"))
+        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"))
+        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"))
+        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)
+
+        syntax.ignore("--" + restOfLine)
+        syntax.ignore(Regex(r"\((?:\*(?:[^*]*\*+)+?\))"))
+        ast = syntax.parseFile(fn)
+        s = schema.Schema(ast)
+        m = mapping.Mapping(s)
+
+        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)
+