Modelica^® Language Specification version 3.7-dev 20 The Modelica Standard Library B Modelica DAE Representation

Appendix A Modelica Concrete Syntax

A.1 Lexical conventions

The following syntactic metasymbols are used (extended BNF):

Syntax	Description
[ $\ldots$ ]	Optional
{ $\ldots$ }	Repeat zero or more times
$\ldots$ \| $\ldots$	Alternatives
" $\mathit{text}$ "	The $\mathit{text}$ is treated as a single token (no white-space between any characters)

The following lexical units are defined:

IDENT =

⬇

NON-DIGIT { DIGIT | NON-DIGIT } | Q-IDENT

Q-IDENT =

⬇

"'" { Q-CHAR | S-ESCAPE } "'"

NON-DIGIT =

⬇

"_" | letters "a"

\ldots

"z" | letters "A"

\ldots

"Z"

DIGIT =

⬇

"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"

Q-CHAR =

⬇

NON-DIGIT | DIGIT

| " " | """ | "." | "," | ":" | ";" | "!" | "?" | "@" | "#" | "$"

| "+" | "-" | "*" | "/" | "^" | "=" | "&" | "|" | "~" | "%"

| "<" | ">" | "(" | ")" | "[" | "]" | "{" | "}""

S-ESCAPE =

⬇

"\'" | "\"" | "\?" | "\\"

| "\a" | "\b" | "\f" | "\n" | "\r" | "\t" | "\v"

STRING =

⬇

""" { S-CHAR | S-ESCAPE } """

see below

DIGIT { DIGIT }

UNSIGNED-INTEGER "." [ UNSIGNED-INTEGER ]

| UNSIGNED_INTEGER [ "." [ UNSIGNED_INTEGER ] ]

( "e" | "E" ) [ "+" | "-" ] UNSIGNED-INTEGER

| "." UNSIGNED-INTEGER [ ( "e" | "E" ) [ "+" | "-" ] UNSIGNED-INTEGER ]

S-CHAR is any member of the Unicode character set (https://unicode.org; see section 13.4 for storing as UTF-8 on files) except double-quote ‘”’, and backslash ‘\’.

For identifiers the redundant escapes (‘\?’ and ‘\""’) are the same as the corresponding non-escaped variants (‘?’ and ’""’). The single quotes are part of an identifier. For example, the identifiers 'x' and x are different.

Note:

•

White-space and comments can be used between separate lexical units and/or symbols, and also separates them. Each lexical unit will consume the maximum number of characters from the input stream. White-space and comments cannot be used inside other lexical units, except for STRING and Q-IDENT where they are treated as part of the STRING or Q-IDENT lexical unit.
•

Concatenation of string literals requires a binary expression. For example, "a" + "b" evaluates to "ab". There is no support for the C/C++ style of concatenating adjacent string literal tokens (for example, "a" "b" becoming "ab").
•

Modelica uses the same comment syntax as C++ and Java (i.e., // signals the start of a line comment and /* $\ldots$ */ is a multi-line comment); comments may contain any Unicode character. Modelica also has structured comments in the form of annotations and string comments.
•

In the grammar, keywords of the Modelica language are highlighted with color, for example, equation.
•

Productions use hyphen as separator both in the grammar and in the text. (Previously the grammar used underscore.)

If a description-string starts with the tag <html> or <HTML>, the entire string is HTML encoded (assumed to end with </html> or </HTML>, but to be rendered as HTML even if the end-tag is missing). Otherwise, the entire string is rendered as is. HTML encoded content may contain links in the same way as class documentation, see section 18.5.

A.2 Grammar

A.2.1 Stored Definition – Within

stored-definition :

⬇

[ within-clause ]

{ [ final ] class-definition ";" }

within-clause :

⬇

within [ name ] ";"

A.2.2 Class Definition

class-definition :

⬇

[ encapsulated ] class-prefixes class-specifier

class-prefixes :

⬇

[ partial ]

( class

| model

| [ operator ] record

| block

| [ expandable ] connector

| type

| package

| [ pure | impure ] [ operator ] function

| operator

)

class-specifier :

⬇

long-class-specifier | short-class-specifier | der-class-specifier

long-class-specifier :

⬇

IDENT description-string composition end IDENT

| extends IDENT [ class-modification ] description-string composition

end IDENT

short-class-specifier :

⬇

IDENT "=" base-prefix type-specifier [ array-subscripts ]

[ class-modification ] description

| IDENT "=" enumeration "(" ( [ enum-list ] | ":" ) ")" description

der-class-specifier :

⬇

IDENT "=" der "(" type-specifier "," IDENT { "," IDENT } ")" description

[ input | output ]

enumeration-literal { "," enumeration-literal }

enumeration-literal :

⬇

IDENT description

composition :

⬇

element-list

{ public element-list

| protected element-list

| equation-section

| algorithm-section

}

[ external [ language-specification ]

[ external-function-call ] [ annotation-clause ] ";"

]

[ annotation-clause ";" ]

language-specification :

⬇

STRING

external-function-call :

⬇

[ component-reference "=" ]

IDENT "(" [ expression-list ] ")"

{ element ";" }

import-clause

| extends-clause

| [ redeclare ]

[ final ]

[ inner ] [ outer ]

( class-definition

| component-clause

| replaceable ( class-definition | component-clause )

[ constraining-clause description ]

)

import-clause :

⬇

import

( IDENT "=" name

| name [ ".*" | "." ( "*" | "{" import-list "}" ) ]

)

description

import-list :

⬇

IDENT { "," IDENT }

A.2.3 Extends

extends-clause :

⬇

extends type-specifier [ class-or-inheritance-modification ] [ annotation-clause ]

constraining-clause :

⬇

constrainedby type-specifier [ class-modification ]

class-or-inheritance-modification :

⬇

"(" [ argument-or-inheritance-modification-list ] ")"

argument-or-inheritance-modification-list :

⬇

( argument | inheritance-modification ) { "," ( argument | inheritance-modification ) }

inheritance-modification :

⬇

break ( connect-equation | IDENT )

A.2.4 Component Clause

component-clause :

⬇

type-prefix type-specifier [ array-subscripts ] component-list

type-prefix :

⬇

[ flow | stream ]

[ discrete | parameter | constant ]

[ input | output ]

component-list :

⬇

component-declaration { "," component-declaration }

component-declaration :

⬇

declaration [ condition-attribute ] description

condition-attribute :

⬇

if expression

declaration :

⬇

IDENT [ array-subscripts ] [ modification ]

A.2.5 Modification

modification :

⬇

class-modification [ "=" modification-expression ]

| "=" modification-expression

modification-expression :

⬇

expression

| break

class-modification :

⬇

"(" [ argument-list ] ")"

argument-list :

⬇

argument { "," argument }

argument :

⬇

element-modification-or-replaceable

| element-redeclaration

element-modification-or-replaceable :

⬇

[ each ] [ final ] ( element-modification | element-replaceable )

element-modification :

⬇

name [ modification ] description-string

element-redeclaration :

⬇

redeclare [ each ] [ final ]

( short-class-definition | component-clause1 | element-replaceable )

element-replaceable :

⬇

replaceable ( short-class-definition | component-clause1 )

[ constraining-clause ]

component-clause1 :

⬇

type-prefix type-specifier component-declaration1

component-declaration1 :

⬇

declaration description

short-class-definition :

⬇

class-prefixes short-class-specifier

A.2.6 Equations

equation-section :

⬇

[ initial ] equation { some-equation ";" }

algorithm-section :

⬇

[ initial ] algorithm { statement ";" }

some-equation :

⬇

( equation-or-procedure

| if-equation

| for-equation

| connect-equation

| when-equation

)

description

equation-or-procedure :

⬇

simple-equation

| function-call

simple-equation :

⬇

simple-expression "=" expression

statement :

⬇

( statement-or-procedure

| "(" output-expression-list ")" ":="

function-call

| break

| return

| if-statement

| for-statement

| while-statement

| when-statement

)

description

statement-or-procedure :

⬇

function-call

| component-reference ":=" expression

| der "(" component-reference ")" ":=" expression

function-call :

⬇

component-reference function-call-args

if-equation :

⬇

if expression then

{ some-equation ";" }

{ elseif expression then

{ some-equation ";" }

}

[ else

{ some-equation ";" }

]

end if

if-statement :

⬇

if expression then

{ statement ";" }

{ elseif expression then

{ statement ";" }

}

[ else

{ statement ";" }

]

end if

for-equation :

⬇

for for-indices loop

{ some-equation ";" }

end for

for-statement :

⬇

for for-indices loop

{ statement ";" }

end for

for-indices :

⬇

for-index { "," for-index }

for-index :

⬇

IDENT [ in expression ]

while-statement :

⬇

while expression loop

{ statement ";" }

end while

when-equation :

⬇

when expression then

{ some-equation ";" }

{ elsewhen expression then

{ some-equation ";" }

}

end when

when-statement :

⬇

when expression then

{ statement ";" }

{ elsewhen expression then

{ statement ";" }

}

end when

connect-equation :

⬇

connect "(" component-reference "," component-reference ")"

[The productions equation-or-procedure and statement-or-procedure are not suitable for recursive descent parsers. A work-around is to left-factor them and for equation-or-procedure introduce semantic checks to ensure that only the grammar above is accepted. ]