def when_statement(tokens, state): kw = keyword parser = (kw("when") + expression + kw("then") + maybe(many(statement + op(";"))) + maybe( many( kw("elsewhen") + expression + kw("then") + maybe(many(statement + op(";"))))) + kw("end") + kw("when")) >> WhenStatement return parser.run(tokens, state)
def when_equation(tokens, state): kw = keyword parser = (kw("when") + expression + kw("then") + maybe(many(equation + op(";"))) + maybe( many( kw("elsewhen") + expression + kw("then") + maybe(many(equation + op(";"))))) + kw("end") + kw("when")) >> WhenEquation return parser.run(tokens, state)
def if_equation(tokens, state): kw = keyword parser = (kw("if") + expression + kw("then") + maybe(many(equation + op(";"))) + maybe( many( kw("elseif") + expression + kw("then") + maybe(many(equation + op(";"))))) + maybe(kw("else") + maybe(many(equation + op(";")))) + kw("end") + kw("if")) >> IfEquation return parser.run(tokens, state)
def short_class_definition(tokens, state): # circular import! from modparc.syntax.class_definition import (class_prefixes, enum_list, base_prefix) parser = (class_prefixes + token_type("ident") + op("=") + (base_prefix + name + maybe(array_subscript) + maybe(class_modification) + comment | keyword('enumeration') + op('(') + (maybe(enum_list) | op(":")) + op(')') + comment)) return (parser >> ShortClassDefinition).run(tokens, state)
def if_statement(tokens, state): kw = keyword parser = (kw("if") + expression + kw("then") + maybe(many(statement + op(";"))) + maybe( many( kw("elseif") + expression + kw("then") + maybe(many(statement + op(";"))))) + maybe(kw("else") + maybe(many(statement + op(";")))) + kw("end") + kw("if")) >> IfStatement return parser.run(tokens, state)
def statement(tokens, state): parser = ((component_reference + (op(":=") + expression | function_call_args) | (op('(') + output_expression_list + op(')') + op(':=') + component_reference + function_call_args) | keyword('break') | keyword('return') | assertion | if_statement | for_statement | while_statement | connect_clause | when_statement) + comment) >> Statement return parser.run(tokens, state)
def class_specifier(tokens, state): normal = (token_type('ident') + string_comment + composition + keyword('end') + token_type('ident')) derived = (token_type('ident') + op("=") + base_prefix + name + maybe(array_subscript) + maybe(class_modification) + comment) enum_def = (token_type('ident') + op("=") + keyword('enumeration') + op("(") + (maybe(enum_list) | op(":")) + op(")") + comment) derivative = (token_type('ident') + op("=") + keyword('der') + op("(") + name + op(",") + token_type('ident') + maybe(many(op(",") + token_type('ident'))) + op(")") + comment) extended = (keyword('extends') + token_type('ident') + maybe(class_modification) + string_comment + composition + keyword("end") + token_type('ident')) parser = (normal | derived | enum_def | derivative | extended) return (parser >> ClassSpecifier).run(tokens, state)
def equation(tokens, state): parser = ((simple_expression + op("=") + expression | if_equation | for_equation | connect_clause | when_equation | assertion | name + function_call_args) + comment) >> Equation return parser.run(tokens, state)
def function_arguments(tokens, state): from modparc.syntax.equations import for_indices # circular dependency # Since funcparserlib doesn't have full backtracking # the `named_arguments` parser is matched first to avoid problems parser = ( named_arguments | function_argument + maybe(op(",") + function_arguments | keyword('for') + for_indices)) return (parser >> FunctionArguments).run(tokens, state)
def primary(tokens, state): kw = keyword parser = (token_type("number") | token_type("string") | kw("false") | kw("true") | (name | kw("der") | kw("initial")) + function_call_args | component_reference | op("(") + output_expression_list + op(")") | (op("[") + expression_list + maybe(many(op(";") + expression_list)) + op("]")) | op("{") + function_arguments + op("}") | kw("end")) return (parser >> Primary).run(tokens, state)
def for_statement(tokens, state): kw = keyword parser = (kw("for") + for_indices + kw("loop") + maybe( many(statement + op(";"))) + kw("end") + kw("for")) >> ForStatement return parser.run(tokens, state)
""" from funcparserlib.parser import many, maybe, Parser # pylint: disable=no-name-in-module, missing-docstring from modparc.syntax import keyword, op, token_type from modparc.syntax.syntax_elements import ( Expression, SimpleExpression, LogicalExpression, LogicalTerm, LogicalFactor, Relation, ArithmeticExpression, Term, Factor, Primary, RelOp, MulOp, AddOp, Name, NamedArgument, NamedArguments, FunctionArgument, FunctionArguments, FunctionCallArgs, ExpressionList, OutputExpressionList, Subscript, ArraySubscript, ComponentReference, StringComment, Annotation, Comment) # pylint: enable=no-name-in-module name = (maybe(op(".")) + (token_type("ident") | keyword("assert")) + maybe(many(op(".") + (token_type("ident") | keyword("assert")))) >> Name) rel_op = op("<") | op("<=") | op(">") | op(">=") | op("==") | op("<>") >> RelOp add_op = op("+") | op("-") | op(".+") | op(".-") >> AddOp mul_op = op("*") | op("/") | op(".*") | op("./") >> MulOp @Parser def primary(tokens, state): kw = keyword parser = (token_type("number") | token_type("string")
def while_equation(tokens, state): kw = keyword parser = (kw("while") + expression + kw("loop") + maybe( many(equation + op(";"))) + kw("end") + kw("while")) >> WhileEquation return parser.run(tokens, state)
def for_equation(tokens, state): kw = keyword parser = (kw("for") + for_indices + kw("loop") + maybe( many(equation + op(";"))) + kw("end") + kw("for")) >> ForEquation return parser.run(tokens, state)
# -*- coding: utf-8 -*- """ stored_definition ---------------------------------- Parser definition for funcparserlib. The definitions are specified in the Appendix B.2.1 of the Modelica Specification 3.3. This is the top-level module used by in the library api as it parses the contents of a Modelica source code file (files with suffix .mo). """ from funcparserlib.parser import many, maybe, skip, finished # pylint: disable=no-name-in-module, missing-docstring from modparc.syntax import keyword, op from modparc.syntax.class_definition import class_definition from modparc.syntax.expressions import name from modparc.syntax.syntax_elements import StoredDefinition # pylint: enable=no-name-in-module stored_definition = (maybe(keyword("within") + maybe(name) + op(";")) + many(maybe(keyword("final")) + class_definition + op(";")) + skip(finished) >> StoredDefinition)
def named_argument(tokens, state): parser = token_type('ident') + op('=') + function_argument return (parser >> NamedArgument).run(tokens, state)
| component_clause1) + maybe(constraining_clause)) >> ElementReplaceable element_redeclaration = (keyword("redeclare") + maybe(keyword("each")) + maybe(keyword("final")) + ((short_class_definition | component_clause1 | element_replaceable))) >> ElementRedeclaration element_modification = (name + maybe(modification) + string_comment >> ElementModification) def km(key): return maybe(keyword(key)) element_modification_or_replaceable = (km('each') + km('final') + (element_modification | element_replaceable) >> ElementModificationOrReplaceable) argument = (element_modification_or_replaceable | element_redeclaration >> Argument) argument_list = argument + maybe(many(op(',') + argument)) >> ArgumentList @Parser def class_modification(tokens, state): parser = op('(') + maybe(argument_list) + op(')') >> ClassModification return parser.run(tokens, state)
from modparc.syntax import keyword, op, token_type from modparc.syntax.expressions import (expression, simple_expression, name, comment, function_call_args, component_reference, output_expression_list) from modparc.syntax.syntax_elements import ( ForIndex, ForIndices, ConnectClause, Equation, IfEquation, ForEquation, WhileEquation, WhenEquation, Statement, IfStatement, ForStatement, WhileStatement, WhenStatement, EquationSection, AlgorithmSection, Assertion) # pylint: enable=no-name-in-module for_index = ( token_type('ident') + maybe(keyword('in') + expression) >> ForIndex) for_indices = for_index + maybe(many(op(',') + for_index)) >> ForIndices connect_clause = (keyword("connect") + op("(") + component_reference + op(",") + component_reference + op(")")) >> ConnectClause assertion = keyword("assert") + function_call_args >> Assertion @Parser def equation(tokens, state): parser = ((simple_expression + op("=") + expression | if_equation | for_equation | connect_clause | when_equation | assertion
string_comment, component_reference, array_subscript, expression_list) from modparc.syntax.extends import extends_clause, constraining_clause from modparc.syntax.modification import class_modification from modparc.syntax.syntax_elements import ( LanguageSpecification, BasePrefix, ExternalFunctionCall, ClassDefinition, Element, ElementList, Composition, ClassSpecifier, ClassPrefixes, EnumerationLiteral, EnumList, ImportList, ImportClause) # pylint: enable=no-name-in-module language_specification = token_type('string') >> LanguageSpecification base_prefix = type_prefix >> BasePrefix external_function_call = ( maybe(component_reference + op("=")) + token_type('ident') + op("(") + maybe(expression_list) + op(")") >> ExternalFunctionCall) @Parser def class_definition(tokens, state): parser = maybe(keyword("encapsulated")) + class_prefixes + class_specifier return (parser >> ClassDefinition).run(tokens, state) def km(key): return maybe(keyword(key)) @Parser def element(tokens, state):
def function_argument(tokens, state): parser = ( keyword("function") + name + op('(') + maybe(named_arguments) + op(')') | expression) return (parser >> FunctionArgument).run(tokens, state)
def modification(tokens, state): parser = (class_modification + maybe(op('=') + expression) | op('=') + expression | op(':=') + expression) >> Modification return parser.run(tokens, state)
def while_statement(tokens, state): kw = keyword parser = (kw("while") + expression + kw("loop") + maybe( many(statement + op(";"))) + kw("end") + kw("while")) >> WhileStatement return parser.run(tokens, state)
def class_modification(tokens, state): parser = op('(') + maybe(argument_list) + op(')') >> ClassModification return parser.run(tokens, state)
# pylint: enable=no-name-in-module kw = keyword type_prefix = (maybe(kw("flow") | kw("stream")) + maybe(kw("discrete") | kw("parameter") | kw("constant")) + maybe(kw("input") | kw("output"))) >> TypePrefix type_specifier = name >> TypeSpecifier condition_attribute = keyword('if') + expression >> ConditionAttribute @Parser def declaration(tokens, state): from .modification import modification parser = (token_type('ident') + maybe(array_subscript) + maybe(modification)) >> Declaration return parser.run(tokens, state) component_declaration = ( declaration + maybe(condition_attribute) + comment >> ComponentDeclaration) component_list = ( component_declaration + maybe(many(op(",") + component_declaration)) >> ComponentList) component_clause = (type_prefix + type_specifier + maybe(array_subscript) + component_list) >> ComponentClause