Glassvision/IfcOpenShell
1
0
Fork 0
mirror of https://github.com/IfcOpenShell/IfcOpenShell.git synced 2026-08-10 17:58:20 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
443af3f7e7be3622ffd498826b9381545d18edd5
IfcOpenShell/src/ifcopenshell-python/ifcopenshell/express/express_parser.py
T

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1497 lines
73 KiB
Python
Raw Normal View History

IfcOpenShell-python licensing and black. See #1082.
2022-01-19 12:18:33 +11:00
# IfcOpenShell - IFC toolkit and geometry engine
# Copyright (C) 2021 Thomas Krijnen <thomas@aecgeeks.com>
#
# This file is part of IfcOpenShell.
#
# IfcOpenShell is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# IfcOpenShell is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with IfcOpenShell. If not, see <http://www.gnu.org/licenses/>.
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
# 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 *
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
else:
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
ABS = (CaselessKeyword("abs")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ABS"))("ABS")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
ABSTRACT = (CaselessKeyword("abstract")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ABSTRACT"))(
"ABSTRACT"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
ACOS = (CaselessKeyword("acos")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ACOS"))("ACOS")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
AGGREGATE = (CaselessKeyword("aggregate")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="AGGREGATE"))(
"AGGREGATE"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
BASED_ON = (CaselessKeyword("based_on")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="BASED_ON"))(
"BASED_ON"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
END_IF = (CaselessKeyword("end_if")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="END_IF"))("END_IF")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
ENTITY = (CaselessKeyword("entity")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ENTITY"))("ENTITY")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
ENUMERATION = (CaselessKeyword("enumeration")).setParseAction(
lambda s, loc, t: Node(s, loc, t, rule="ENUMERATION")
)("ENUMERATION")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
EXTENSIBLE = (CaselessKeyword("extensible")).setParseAction(
lambda s, loc, t: Node(s, loc, t, rule="EXTENSIBLE")
)("EXTENSIBLE")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
LOBOUND = (CaselessKeyword("lobound")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="LOBOUND"))(
"LOBOUND"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
OPTIONAL = (CaselessKeyword("optional")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="OPTIONAL"))(
"OPTIONAL"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
OR = (CaselessKeyword("or")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="OR"))("OR")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
OTHERWISE = (CaselessKeyword("otherwise")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="OTHERWISE"))(
"OTHERWISE"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
PI = (CaselessKeyword("pi")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="PI"))("PI")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
PROCEDURE = (CaselessKeyword("procedure")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="PROCEDURE"))(
"PROCEDURE"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
REFERENCE = (CaselessKeyword("reference")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="REFERENCE"))(
"REFERENCE"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
REMOVE = (CaselessKeyword("remove")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="REMOVE"))("REMOVE")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
RENAMED = (CaselessKeyword("renamed")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="RENAMED"))(
"RENAMED"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
ROLESOF = (CaselessKeyword("rolesof")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="ROLESOF"))(
"ROLESOF"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
TOTAL_OVER = (CaselessKeyword("total_over")).setParseAction(
lambda s, loc, t: Node(s, loc, t, rule="TOTAL_OVER")
)("TOTAL_OVER")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
UNKNOWN = (CaselessKeyword("unknown")).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="UNKNOWN"))(
"UNKNOWN"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
digits = ((digit + ZeroOrMore(digit)))("digits")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
octet = ((hex_digit + hex_digit)).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="octet"))("octet")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
integer_literal = (digits)("integer_literal")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
abstract_entity_declaration = (ABSTRACT)("abstract_entity_declaration")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
attribute_id = (simple_id)("attribute_id")
boolean_type = (BOOLEAN)("boolean_type")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
constant_id = (simple_id)("constant_id")
entity_id = (simple_id)("entity_id")
enumeration_id = (simple_id)("enumeration_id")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
function_id = (simple_id)("function_id")
integer_type = (INTEGER)("integer_type")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
logical_type = (LOGICAL)("logical_type")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
number_type = (NUMBER)("number_type")
parameter_id = (simple_id)("parameter_id")
procedure_id = (simple_id)("procedure_id")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
rule_id = (simple_id)("rule_id")
rule_label_id = (simple_id)("rule_label_id")
schema_id = (simple_id)("schema_id")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
subtype_constraint_id = (simple_id)("subtype_constraint_id")
type_id = (simple_id)("type_id")
type_label_id = (simple_id)("type_label_id")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
unary_op = ((CaselessLiteral("+") | CaselessLiteral("-") | NOT)).setParseAction(
lambda s, loc, t: Node(s, loc, t, rule="unary_op")
)("unary_op")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
variable_id = (simple_id)("variable_id")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
named_types = ((entity_ref | type_ref)).setParseAction(NamedType)("named_types")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
population = (entity_ref)("population")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
schema_version_id = (string_literal)("schema_version_id")
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
logical_expression << (expression)
numeric_expression << (simple_expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
remark << (((embedded_remark | tail_remark))).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="remark"))
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"))
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
inverse_clause << (((INVERSE + inverse_attr + ZeroOrMore(inverse_attr)))).setParseAction(AttributeList)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"))
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
increment << (numeric_expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
aggregate_type << (
((AGGREGATE + Optional((CaselessLiteral(":") + type_label)) + OF + parameter_type))
).setParseAction(lambda s, loc, t: Node(s, loc, t, rule="aggregate_type"))
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
index_1 << (index)
bound_2 << (numeric_expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
factor << (((simple_factor + Optional((CaselessLiteral("**") + simple_factor))))).setParseAction(
lambda s, loc, t: Node(s, loc, t, rule="factor")
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
interval_item << (simple_expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"))
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
interval_low << (simple_expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
string_type << (((STRING + Optional(width_spec)))).setParseAction(StringType)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"))
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
index << (numeric_expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"))
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
precision_spec << (numeric_expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"))
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
derive_clause << (((DERIVE + derived_attr + ZeroOrMore(derived_attr)))).setParseAction(AttributeList)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
function_call << ((((built_in_function | function_ref) + actual_parameter_list))).setParseAction(
lambda s, loc, t: Node(s, loc, t, rule="function_call")
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
case_label << (expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
aggregate_source << (simple_expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
where_clause << (
((WHERE + domain_rule + CaselessLiteral(";") + ZeroOrMore((domain_rule + CaselessLiteral(";")))))
).setParseAction(lambda s, loc, t: ListNode(s, loc, t, rule="where_clause"))
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
repetition << (numeric_expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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")
)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
index_2 << (index)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"))
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
parameter << (expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"))
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
aggregation_types << (((array_type | bag_type | list_type | set_type))).setParseAction(AggregationType)
selector << (expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
bound_1 << (numeric_expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"))
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
width << (numeric_expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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"))
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
interval_high << (simple_expression)
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
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)
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
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
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
if __name__ == "__main__":
m = parse(sys.argv[1])
import importlib
Run black, and add black to a "qa" target to make it a standardised process.
2021-09-09 21:27:23 +10:00
Add generator expresss_parser.py
2020-12-20 11:10:21 +01:00
for output in sys.argv[2:]:
mdl = importlib.import_module(output)
mdl.Generator(m).emit()
sys.stdout.write(m.schema.name)
Reference in New Issue Copy Permalink