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
