Grammar

Document Status: Draft / Work in Progress

This article is a draft and work in progress. Feel free to comment and discuss on the issue tracker.

Remarks

Several questions have to be addressed:

• What is the definition of "id“, "num", "basic", "real" und "string"?
• What is the semantic of "if (assign)" for "assign" -> "loc = assign"?
• The grammar is ambiguous for "if else" (Dangling Else). How to solve it (prioritoes)?
• What is the difference between "id" and "loc.id" for "loc"?
• What is the semantic for "break" outside of a loop?

(Author: Sven, Translator: Flo)

Grammar rules

The provided grammmar can be found here: https://github.com/swp-uebersetzerbau-ss13/common/blob/master/doc/quellsprache.pdf?raw=true

program -> decls stmts
block -> {decls stmts}
decls -> decls decl | ϵ
decl -> type *id*;
type -> type [*num*] | *basic* | *record* {decls}
stmts -> stmts stmt | ϵ

stmt -> assign;
     | *if*(assign) stmt
     | *if*( assign ) stmt *else* stmt
     | *while*( assign ) stmt
     | *do* stmt *while* ( assign );
     | *break*;
     | *return*;
     | *return* loc;
     | *print* loc;
     | block
loc -> loc [assign] | *id* | loc.*id*

assign -> loc=assign | bool
bool -> bool||join | join
join -> join&&equality | equality
equality -> equality==rel | equality!=rel | rel
rel -> expr<expr | expr<=expr | expr>=expr | expr>expr | expr
expr -> expr+term | expr-term | term
term -> term*unary | term/unary | unary
unary -> !unary | -unary | factor
factor -> (assign) | loc | *num* | *real* | *true* | *false* | *string*

basic -> long | double | string | bool

string -> " (.*) " //?? escaping?

id -> ...

Note: *...* marks terminals

terminal definition

digit -> [0-9]
digits -> digit+
integralDigits -> -? digits
exponent -> ((e | E) integralDigits)
num -> digits exponent?
real -> digits . digits exponent?
basic -> (long | double | string | bool)
alpha -> [a-zA-Z]
alphaNumeric -> [a-zA-Z0-9]
id -> alpha alphaNumeric*

Semantic

Definition of semantic of each term (if necessary)

Variables

All variables are initialized with a default value:

• long - 0
• double - 0.0
• bool - false
• string - ""

All arrays and records are initialized similar to this.

Return

The return-statement may have a parameter of type LONG but no other. The value returns by non-parameter return is always 0 (and if there is no return defined and the last statement executed, the program also returns 0. An execution path with statements after the return is invalid.

! (unary not)

The unary not ! may only be used on bool-type values.

- (unary minus)

The unary minus - may only be used on long- or double-type values.

if - else

The condition value of the if-statement always has to be of bool-type and an else always belongs to the last defined if which has no associated else.

while / do-while

The condition value of the loop-statements always has to be of bool-type.

break

The break-statement is only valid inside of a loop. It aborts the loop execution of the directly containing loop.

+ - binary add

The binary add works for all primitive type by following rules:

• Two long values results into a long value.
• A double and a long or two double values results into a long value.
• If at least one value is a string it works like a string concat inclusive type conversions equal to print statement

print

Print writes the value of the parameter to stdout.