Abstrakte Syntax

A Abstrakte Syntax

Team: Karsten Stahl, Martin Steffen, und alle anderen

Folgende erweiterte BNF-Notation faßt die abstrakte Syntax als gemeinsame Zwischenrepresentierung zusammen. Abgesehen von einigen Namenkonventionen (Großschreibung) ist die Umsetzung in Java trivial. Jeder nichtterminale Eintrag wird ein Klasse. Alternativen, gekennzeichnet durch |, sind Unterklassen der abstrakten Klasse, deren Unterfälle sie bilden. Die Einträge der mittleren Spalte werden als Felder der Klassen repräsentiert. Die Konstruktoren sind, bis auf die Reihenfolge der Argumente, durch die Felder der Klasse festgelegt.¹ Die Listen der EBNF wurden als java.lang.Enumeration-Klassen implementiert. Graphische Information zur Positionierung, die nur für den Editor relevant ist, wurde nicht mit in die EBNF mit aufgenomment.

                      SFC ::=  istep      : step
                               steps      : step list
                               transs     : transition list
                               actions    : action list
                               declist    : declaration list
                     step ::=  name       : string
                               actions    : stepaction list
               stepaction ::=  qualifier  : action_qualifier
                               a_name     : string
                   action ::=  a_name     : string
                               sap        : stmt list  (* simple assignment program *)
                    stmt  ::=               skip
                           |                assign
                   assign ::=  var        : variable
                               val        : expr
                 variable ::=  name       : string
                               type       : type
         action_qualifier ::=  Nqual                            (* may be extended *)

               transition ::=  source     : step list
                               guard      : expr
                               target     : step list

              declaration ::=  var        : variable
                               type       : type
                               val        : constval

               expr       ::=               b_expr
                           |                u_expr
                           |                constval
                           |                variable
             b_expr       ::=  left_expr  : expr
                               right_expr : expr
                               op         : operand
                               type       : type
             u_expr       ::=  sub_expr   : expr
                               op         : operand             
                               type       : type
               operand    ::=               PLUS | MINUS | TIMES | DIV  (* Operand als *)
                           |                AND | OR | NEG              (* Konstanten in expr *)
                           |                LESS | GREATER | LEQ | GEQ | EQ 
                constval  ::=               ...| -2 | -1 | 0 | 1 | ... | true | false
                type      ::=               inttype
                           |                booltype