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 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 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 km(key):
return maybe(keyword(key))
# 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)
component_declaration1 = declaration + comment >> ComponentDeclaration1
component_clause1 = (type_prefix + type_specifier + component_declaration1
>> ComponentClause1)
element_replaceable = (keyword("replaceable") + (short_class_definition
| 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))
# pylint: disable=no-name-in-module, missing-docstring
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
def class_definition(tokens, state):
parser = maybe(keyword("encapsulated")) + class_prefixes + class_specifier
return (parser >> ClassDefinition).run(tokens, state)
@Parser
def element(tokens, state):
kw = keyword
parser = (import_clause | extends_clause
| km('redeclare') + km('final') + km('inner') + km('outer') +
((class_definition | component_clause) | kw('replaceable') +
(class_definition | component_clause) +
maybe(constraining_clause + comment)))
return (parser >> Element).run(tokens, state)
element_list = maybe(many(element + op(';'))) >> ElementList
composition = (element_list + maybe(
many(
keyword("public") + element_list | keyword("protected") + element_list
| equation_section | algorithm_section)) + maybe(
keyword("external") + maybe(language_specification) +
maybe(external_function_call) + maybe(annotation) + op(";")) +
maybe(annotation + op(";")) >> Composition)
@Parser
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("(") +
def function_argument(tokens, state):
parser = (
keyword("function") + name + op('(') + maybe(named_arguments) + op(')')
| expression)
return (parser >> FunctionArgument).run(tokens, state)
def annotation(tokens, state):
from .modification import class_modification # circular dependency
parser = keyword('annotation') + class_modification >> Annotation
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")
# -*- 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)
from modparc.syntax.syntax_elements import (TypePrefix, TypeSpecifier,
ConditionAttribute, Declaration,
ComponentDeclaration,
ComponentList, ComponentClause)
# 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)) >>
def constraining_clause(tokens, state):
from .modification import class_modification
parser = keyword('constrainedby') + name + maybe(class_modification)
return (parser >> ConstrainingClause).run(tokens, state)
def extends_clause(tokens, state):
from .modification import class_modification
parser = (keyword('extends') + name + maybe(class_modification) +
maybe(annotation)) >> ExtendsClause
return parser.run(tokens, state)
