JavaCompilerCore/tools/JavaParser.jay

%{
import de.dhbwstuttgart.typeinference.Menge;
class JavaParser{
public Menge path = new Menge();
%}

%token <Token> ABSTRACT
%token <Token> BOOLEAN
%token BREAK
%token CASE
%token CATCH
%token <Token> CHAR
%token CLASS
%token CONTINUE
%token DEFAULT
%token DO
%token ELSE
%token <Token> EXTENDS
%token FINALLY
%token FOR
%token IF
%token <Token> INSTANCEOF
%token <Token> INT
%token <Token> NEW
%token <Token> PRIVATE
%token <Token> PROTECTED
%token <Token> PUBLIC
%token RETURN
%token <Token> STATIC
%token SUPER
%token SWITCH
%token <Token> THIS
%token THROW
%token <Token> THROWS
%token TRY
%token <Token> VOID
%token WHILE
%token <Token> INTLITERAL
%token <Token> BOOLLITERAL
%token JNULL
%token <Token> CHARLITERAL
%token <Token> STRINGLITERAL
%token <Token>  IDENTIFIER
%token EQUAL
%token LESSEQUAL
%token GREATEREQUAL
%token NOTEQUAL
%token LOGICALOR
%token LOGICALAND
%token <Token> INCREMENT
%token <Token> DECREMENT
%token SHIFTLEFT
%token SHIFTRIGHT
%token UNSIGNEDSHIFTRIGHT
%token SIGNEDSHIFTRIGHT
%token PLUSEQUAL
%token MINUSEQUAL
%token TIMESEQUAL
%token DIVIDEEQUAL
%token ANDEQUAL
%token OREQUAL
%token XOREQUAL
%token MODULOEQUAL
%token SHIFTLEFTEQUAL
%token SIGNEDSHIFTRIGHTEQUAL
%token UNSIGNEDSHIFTRIGHTEQUAL
%token BRACE
%token RELOP
%token OP
%token EOF

%type <Class> classdeclaration
%type <ClassBody> classbody
%type <InstVarDecl> fielddeclaration
%type <Method> methodheader
%type <Method> methoddeclaration
%type <Method> methoddeclarator
%type <ClassBody> classbodydeclarations
%type <FieldDecl> classbodydeclaration
%type <FieldDecl> classmemberdeclaration
%type <InstVarDecl> variabledeclarators
%type <DeclId> variabledeclarator
%type <DeclId> variabledeclaratorid
%type <UsedId> simplename
%type <UsedId> qualifiedname
%type <UsedId> name
%type <UsedId> super
%type <UsedId> classtype
%type <UsedId> classorinterfacetype
%type <BaseType> integraltype
%type <BaseType> numerictype
%type <BaseType> primitivetype
%type <RefType> referencetype
%type <RefType> classtypelist
%type <Type > type
%type <Modifiers> modifiers
%type <Modifier> modifier
%type <Block> block
%type <Block> methodbody
%type <Block> blockstatements
%type <LocalVarDecl> localvariabledeclarationstatement
%type <LocalVarDecl> localvariabledeclaration
%type <ExceptionList> throws
%type <FormalParameter> formalparameter
%type <ParameterList> formalparameterlist
%type <Literal> literal
%type <Expr> primarynonewarray
%type <Expr> primary
%type <Expr> postfixexpression
%type <Expr> unaryexpressionnotplusminus
%type <Expr> unaryexpression
%type <Expr> multiplicativeexpression
%type <Expr> additiveexpression
%type <Expr> shiftexpression
%type <Expr> relationalexpression
%type <Expr> equalityexpression
%type <Expr> andexpression
%type <Expr> exclusiveorexpression
%type <Expr> inclusiveorexpression
%type <Expr> conditionalandexpression
%type <Expr> conditionalorexpression
%type <Expr> conditionalexpression
%type <Expr> assignmentexpression
%type <Expr> expression
%type <Expr> statementexpression
%type <Expr> preincrementexpression
%type <Expr> predecrementexpression
%type <Expr> postincrementexpression
%type <Expr> postdecrementexpression
%type <ExprStmt> expressionstatement
%type <ExprStmt> variableinitializer
%type <Statement> statementwithouttrailingsubstatement
%type <Statement> blockstatement
%type <Statement> statement
%type <Statement> statementnoshortif
%type <WhileStmt> whilestatement
%type <WhileStmt> whilestatementnoshortif
%type <IfStmt> ifthenstatement
%type <IfStmt> ifthenelsestatement
%type <IfStmt> ifthenelsestatementnoshortif
%type <EmptyStmt> emptystatement
%type <Return> returnstatement
%type <NewClass> classinstancecreationexpression
%type <SourceFile> compilationunit
%type <SourceFile> typedeclarations
%type <Assign> assignment
%type <Operator> assignmentoperator
%type <UsedId> lefthandside
%type <ArgumentList> argumentlist
%type <MethodCall> methodinvocation
%type <Class> typedeclaration
%type <FieldDecl> constructordeclaration
%type <Constructor> constructordeclarator
%type <Block> constructorbody
%type <Statement> explicitconstructorinvocation
%type <Method> staticinitializer
%type <CastExpr> castexpression
%type <ParaList> paralist
%left ','
%%

compilationunit                  :typedeclarations
					{
						$$=$1;
					}

typedeclarations                 :typedeclaration
					{
						SourceFile Scfile = new SourceFile();
						Scfile.set_Class($1);
						$$=Scfile;
					}
				 |typedeclarations typedeclaration
					{
						$1.set_Class($2);
						$$=$1;
					}

name				:qualifiedname
					{
						$$=$1;
					}
				    |simplename
					{
						$$=$1;
					}

typedeclaration                  :classdeclaration
					{
						$$=$1;
					}

qualifiedname                    : name '.' IDENTIFIER
					{
						$1.set_Name($3.getLexem());
						$$=$1;
					}

simplename                       : IDENTIFIER
					{
						UsedId UI = new UsedId();
						UI.set_Name( $1.getLexem() );
						$$ = UI;
					}

classdeclaration 		 : CLASS IDENTIFIER classbody
					{
						MyCompiler.Debug("P->Neue Klasse: " + $2.getLexem(), 3);
						Class C = new Class();
						ClassDeclId CDI = new ClassDeclId();
						CDI.set_classname( $2.getLexem() );
						C.set_ClassDeclId( CDI );
						C.set_ClassBody($3);
						$$ = C;
					}

                 		 | modifiers CLASS IDENTIFIER classbody
					{
						Class Cmod = new Class();
						ClassDeclId CDImod = new ClassDeclId();
						CDImod.set_Modifiers($1);
						CDImod.set_classname($3.getLexem());
						Cmod.set_ClassDeclId(CDImod);
						Cmod.set_ClassBody($4);
						$$ = Cmod;
					}

                 		 | CLASS IDENTIFIER super classbody
					{
						Class Csup = new Class();
						ClassDeclId CDIsup = new ClassDeclId();
						CDIsup.set_classname($2.getLexem());
						Csup.set_ClassDeclId(CDIsup);
						Csup.set_UsedId($3);
						Csup.set_ClassBody($4);
						$$ = Csup;
					}

				|modifiers CLASS IDENTIFIER super classbody
					{
						Class Cmodsup = new Class();
 						ClassDeclId CDImodsup = new ClassDeclId();
						CDImodsup.set_Modifiers($1);
						CDImodsup.set_classname($3.getLexem());
						Cmodsup.set_ClassDeclId(CDImodsup);
						Cmodsup.set_UsedId($4);
						Cmodsup.set_ClassBody($5);
						$$ = Cmodsup;
					}
				| modifiers CLASS IDENTIFIER '<'paralist'>'classbody
					{
						Class Cmod = new Class();
						ClassDeclId CDImod = new ClassDeclId();
						CDImod.set_Modifiers($1);
						CDImod.set_classname($3.getLexem());
						Cmod.set_ClassDeclId(CDImod);
						Cmod.set_ParaList($5.get_ParaList());
						Cmod.set_ClassBody($7);
						$$ = Cmod;
					}

				 |CLASS IDENTIFIER '<' paralist	'>'classbody
				 	{
						Class C = new Class();
						ClassDeclId CDI = new ClassDeclId();
						CDI.set_classname($2.getLexem());
						C.set_ClassDeclId(CDI);
						C.set_ClassBody($6);
						C.set_ParaList($4.get_ParaList());
						$$ = C;
					}

			         | CLASS IDENTIFIER '<' paralist '>'super classbody
					{
						MyCompiler.Debug( "Klassendefinition: Basisklassen-Parameter = " + $4.get_ParaList(), 3 );
						MyCompiler.Debug( "Klassendefinition: Superklassen-Parameter = " + $6.get_ParaList(), 3 );
						MyCompiler.Debug( "Klassendefinition: Superklassen-Parameter = " + $6.get_ParaList().hashCode(), 3 );
						Class Csup = new Class();
						ClassDeclId CDIsup = new ClassDeclId();
						CDIsup.set_classname($2.getLexem());
						Csup.set_ClassDeclId(CDIsup);
						Csup.set_ParaList($4.get_ParaList());
						Csup.set_UsedId($6);
						Csup.set_ClassBody($7);
						$$ = Csup;
					}

				|modifiers CLASS IDENTIFIER '<'paralist'>'super classbody
					{
						Class Cmodsup = new Class();
						ClassDeclId CDImodsup = new ClassDeclId();
						CDImodsup.set_Modifiers($1);
						CDImodsup.set_classname($3.getLexem());
						Cmodsup.set_ClassDeclId(CDImodsup);
						Cmodsup.set_ParaList($5.get_ParaList());
						Cmodsup.set_UsedId($7);
						Cmodsup.set_ClassBody($8);
						$$ = Cmodsup;
					}


paralist			: IDENTIFIER
					{
						ParaList pl = new ParaList();
						pl.paralist.addElement( new TyploseVariable($1.getLexem()) );
                        MyCompiler.Debug( "IDENTIFIER --> Paralist f<>r " + $1.getLexem() + " TV", 3 );
						$$ = pl;
					}

                    | IDENTIFIER '<' paralist '>'
					{
						ParaList pl = new ParaList();
                        RefType t = new RefType( $1.getLexem() );
                        t.set_ParaList( $3.get_ParaList() );
                        pl.paralist.addElement(t);
                        MyCompiler.Debug( "IDENTIFIER '<' paralist '>' --> Paralist f<>r " + $1.getLexem() + ": RefType", 3 );
						$$ = pl;
                                        }

                    | paralist ',' IDENTIFIER
                    {
                    	$1.paralist.addElement(new TyploseVariable($3.getLexem()));
                    	MyCompiler.Debug( "paralist ',' IDENTIFIER --> Paralist f<>r " + $3.getLexem() + ": TV", 3 );
                    	MyCompiler.Debug( "paralist: " + $1.paralist, 3 );
                    	$$=$1;
                    }
                    
                    | paralist ',' IDENTIFIER '<' paralist '>'
                    {
                        RefType t = new RefType( $3.getLexem() );
                        t.set_ParaList( $5.get_ParaList() );
                        $1.paralist.addElement(t);
                        MyCompiler.Debug( "paralist ',' IDENTIFIER '<' paralist '>' --> Paralist f<>r " + $3.getLexem() + ": RefType", 3 );
                        $$=$1;
                    }

classbody                        : '{' '}'
				        {
						ClassBody CB = new ClassBody();
						$$ = CB;
					}

				 | '{'classbodydeclarations '}'
				        {
						$$ = $2;
					}

modifiers                        :modifier
					{
						Modifiers Mod = new Modifiers();
						Mod.modifier.addElement($1);
						$$ = Mod;
				  	}
				 |modifiers modifier
					{
						$1.modifier.addElement($2);
						$$ = $1;
					}

super                            :EXTENDS classtype
					{
						$$ = $2;
					}

classbodydeclarations            :  classbodydeclaration
				        {
						ClassBody CB = new ClassBody();
						CB.set_FieldDecl( $1 );
						$$=CB;
					}
				 |  classbodydeclarations classbodydeclaration
				        {
						$1.set_FieldDecl($2);
						$$ = $1;
					}


modifier                         :  PUBLIC
					{
						Public Pub = new Public();
						$$=Pub;
					}
				 |  PROTECTED
					{
						Protected Pro = new Protected();
						$$=Pro;
					}
                                 |  PRIVATE
					{
						Private Pri = new Private();
						$$=Pri;
					}
                                 |  STATIC
					{
						Static Sta = new Static();
						$$=Sta;
					}
                                 |  ABSTRACT
				        {
						Abstract Abs = new Abstract();
						$$=Abs;
					}

classtype : classorinterfacetype
            {
                $$ = $1;
            }
			| classorinterfacetype	'<'paralist'>'
			{
				$1.set_ParaList($3.get_ParaList());
				
				/* otth: originale (also diese) Parameterliste retten */
				((UsedId)$1).vParaOrg = new Menge( $3.get_ParaList() );
				
				$$ = $1;
			}

classbodydeclaration             : classmemberdeclaration
				 	{
						$$=$1;
					}
				 | staticinitializer
					{
						$$=$1;
					}
				 | constructordeclaration
					{
						$$=$1;
					}

classorinterfacetype :  name
				        {
					        $$=$1;
					    }

classmemberdeclaration :    fielddeclaration
				            {
						        $$=$1;
					        }
				 |  methoddeclaration
					{
						$$=$1;
					}

staticinitializer                : STATIC block
					{
						Method STAT = new Method();
						DeclId DST = new DeclId();
						DST.set_Name($1.getLexem());
						STAT.set_DeclId(DST);
						Static ST = new Static();
						Modifiers MOD = new Modifiers();
						MOD.modifier.addElement(ST);
						STAT.set_Modifiers(MOD);
						STAT.set_Block($2);
						$$=STAT;
					}

constructordeclaration           : constructordeclarator constructorbody
				 	{
						$1.set_Block($2);
						$$ = $1;
					}
				 |  modifiers constructordeclarator constructorbody
					{
						$2.set_Block($3);
						$2.set_Modifiers($1);
						$$ = $2;
					}

fielddeclaration : type variabledeclarators ';'
				 {
				    MyCompiler.Debug("T->Parser->fielddeclaration ...: type " + $1, 5);
					$2.set_Type($1);
				    $$ = $2;
				 }

 				 | modifiers type variabledeclarators ';'
					{
						$3.set_Type($2);
					 	for(int i=0;i<($3.declid.size());i++)
						{
							$3.declid.setElementAt((((DeclId)($3.declid.elementAt(i))).modifiers=$1),i);
						}
						$$ = $3;
					}

methoddeclaration   : methodheader methodbody
				    {
						$1.set_Block($2);
						$$=$1;
					}

block                              : '{' '}'

					{
						Block Bl = new Block();
						$$=Bl;
					}

				   | '{' blockstatements '}'
					{
						$$=$2;
					}

constructordeclarator		   :  simplename '(' ')'
				        {
						Constructor CON = new Constructor();
						DeclId DIDCon = new DeclId();
						DIDCon.set_Name($1.get_Name_1Element());
						CON.set_DeclId(DIDCon);
						$$=CON;
					}
				   |  simplename '('formalparameterlist')'
				        {
						Constructor CONpara = new Constructor();
						DeclId DIconpara = new DeclId();
						DIconpara.set_Name($1.get_Name_1Element());
						CONpara.set_DeclId(DIconpara);
						CONpara.set_ParaList($3);
						$$=CONpara;
					}

constructorbody			   :  '{' '}'
					{
						Block CBL = new Block();
						$$=CBL;
					}
				   |   '{' explicitconstructorinvocation '}'
				   	{
						Block CBLexpl = new Block();
						CBLexpl.set_Statement($2);
						$$=CBLexpl;
					}
				   |   '{' blockstatements '}'
				        {
						$$=$2;
					}
				   |  '{'explicitconstructorinvocation blockstatements '}'
					{
						Block CBes = new Block();
						CBes.set_Statement($2);
						for(int j=0;j<$3.statements.size();j++)
						{
							CBes.set_Statement((Statement)$3.statements.elementAt(j));
						}
						$$=CBes;
					}

throws				   : THROWS classtypelist
					{
						ExceptionList EL = new ExceptionList();
						EL.set_addElem($2);
						$$=EL;
					}

methodheader	    : type methoddeclarator
					{
						$2.set_ReturnType($1);
						$$=$2;
					}
				    | modifiers type methoddeclarator
				    {
						$3.set_Modifiers($1);
						$3.set_ReturnType($2);
						$$=$3;
					}
				    | type methoddeclarator throws
					{
						$2.set_ReturnType($1);
						$2.set_ExceptionList($3);
						$$=$2;
					}
				    | modifiers type methoddeclarator throws
				    {
						$3.set_Modifiers($1);
						$3.set_ReturnType($2);
						$3.set_ExceptionList($4);
						$$=$3;
					}
				    | VOID methoddeclarator
					{
						Type Voit = new Type();
						Voit.set_Type($1.getLexem());
						$2.set_ReturnType(Voit);
						$$=$2;
					}
				    | modifiers VOID methoddeclarator
					{
						Type voit = new Type();
						voit.set_Type($2.getLexem());
						$3.set_Modifiers($1);
						$3.set_ReturnType(voit);
						$$=$3;
					}
                    | VOID methoddeclarator throws
					{
						Type voyt = new Type();
						voyt.set_Type($1.getLexem());
						$2.set_ReturnType(voyt);
						$2.set_ExceptionList($3);
						$$=$2;
					}
				    | modifiers VOID methoddeclarator throws
					{
						Type voyd = new Type();
						voyd.set_Type($2.getLexem());
						$3.set_Modifiers($1);
						$3.set_ReturnType(voyd);
						$3.set_ExceptionList($4);
						$$=$3;
					}

type                : primitivetype
 					{
						$$=$1;
					}
				    |referencetype
					{
						$$=$1;
					}

variabledeclarators : variabledeclarator
					{
						InstVarDecl IVD = new InstVarDecl();
						IVD.declid.addElement( $1 );
						$$ = IVD;
					}
				    | variabledeclarators ',' variabledeclarator
					{
						$1.declid.addElement($3);
						$$=$1;
					}

methodbody          : block
			        {
						$$=$1;
					}

blockstatements     : blockstatement
					{
						Block Blstat = new Block();
						Blstat.set_Statement($1);
						$$=Blstat;
					}

				    | blockstatements blockstatement
	  			    {
						$1.set_Statement($2);
						$$=$1;
					}

formalparameterlist :formalparameter
					{
						ParameterList PL = new ParameterList();
						PL.set_AddParameter($1);
						$$ = PL;
					}
				     |formalparameterlist ',' formalparameter
					{
						$1.set_AddParameter($3);
						$$ = $1;
					}

explicitconstructorinvocation        : THIS '(' ')' ';'
				        {
						This THCON = new This();
						$$=THCON;
					}
				     |THIS '(' argumentlist ')' ';'
					{
						This THCONargl = new This();
						THCONargl.set_ArgumentList($3);
						$$=THCONargl;
					}
				    // |SUPER '(' ')' ';'
				    // |SUPER '(' argumentlist ')' ';'

classtypelist : classtype
				{
				    RefType RT = new RefType();
					RT.set_UsedId($1);
					RT.set_Type(RT.used.get_Name_1Element());
					$$=RT;
				 }
              | classtypelist ',' classtype
				{
				    $1.set_UsedId($3);
					$1.set_Type($1.used.get_Name_1Element());
					$$=$1;
				}

methoddeclarator    :IDENTIFIER '(' ')'
				    {
						Method met = new Method();
						DeclId DImethod = new DeclId();
						DImethod.set_Name($1.getLexem());
						met.set_DeclId(DImethod);
						$$ = met;
					}
				    |IDENTIFIER '(' formalparameterlist ')'
					{
					    Method met_para = new Method();
						DeclId Dimet_para = new DeclId();
						Dimet_para.set_Name($1.getLexem());
						met_para.set_DeclId(Dimet_para);
						met_para.set_ParaList($3);
						$$ = met_para;
					}

primitivetype                        :BOOLEAN
					{
						BooleanType BT = new BooleanType();
						BT.set_Type($1.getLexem());
						$$=BT;
					}
				     |numerictype
				        {
						$$=$1;
					}

referencetype                        :classorinterfacetype
					{
						MyCompiler.Debug("T->Parser->referenctype: " + $1, 5);
						RefType RT = new RefType();
						RT.set_UsedId($1);
						RT.set_Type(RT.used.get_Name_1Element());
						$$=RT;
					}

variabledeclarator  : variabledeclaratorid
					{
						$$=$1;
					}

				    | variabledeclaratorid '=' variableinitializer
					{
						$1.set_Wert($3);
						$$=$1;
					}

	                | '<' paralist'>' variabledeclaratorid '=' variableinitializer
					{
						$4.set_Wert($6);
						$4.set_Paratyp($2.get_ParaList());
						$$=$4;
					}

blockstatement                       :localvariabledeclarationstatement
					{
						$$=$1;
					}
				     |statement
				        {
						$$=$1;
					}

funtype				: funtypeortype '(' funtypelist ')'
					{

					}

funtypelist			: funtypeortype
					{

					}
					| funtypelist ',' funtypeortype
					{

					}

funtypeortype		: funtype
					{

					}
					| type
					{
					$$=$1;
					}

formalparameter     : funtype variabledeclaratorid
				      {
						FormalParameter FP = new FormalParameter();
						FP.set_Type($1);
						FP.set_DeclId($2);
						$$=FP;
					  }

                      /* otth: Methodenargumente koennen hiermit auch polymorph sein. */
                      | funtype '<'paralist'>' variabledeclaratorid
				      {
                        /* Parameterliste setzen */
                        $5.set_Paratyp($3.get_ParaList());

						FormalParameter FP = new FormalParameter();
						FP.set_Type($1);
						FP.set_DeclId($5);
						$$=FP;

						MyCompiler.Debug("P->Polymorphes Methodenargument hinzugefuegt: Name = " + $5.get_Name() + " Typ = " + $1.get_Type(), 3);
					  }

argumentlist                         : expression
					{
						ArgumentList AL = new ArgumentList();
						AL.expr.addElement($1);
						$$=AL;
					}
				     |argumentlist ',' expression
				        {
						$1.expr.addElement($3);
						$$=$1;
					}

numerictype                          :integraltype
					{
						$$=$1;
					}

variabledeclaratorid                 :IDENTIFIER
					{
						DeclId DI = new DeclId();
						DI.set_Name($1.getLexem());
						$$=DI;
					}

variableinitializer                  :expression
					{
						$$=$1;
					}

localvariabledeclarationstatement    :localvariabledeclaration ';'
				        {
						$$=$1;
					}

statement                            :statementwithouttrailingsubstatement
					{
						$$=$1;
					}
				     |ifthenstatement
					{
						$$=$1;
					}
				     |ifthenelsestatement
					{
						$$=$1;
					}
				     |whilestatement
					{
						$$=$1;
					}

expression                           :assignmentexpression
					{
						$$=$1;
					}
				     |classinstancecreationexpression
					{
						$$=$1;
					}

integraltype                         :INT
					{
						IntegerType IT = new IntegerType();
						IT.set_Type($1.getLexem());
						$$=IT;
					}
                                     | CHAR
					{
						CharacterType CT = new CharacterType();
						CT.set_Type($1.getLexem());
						$$=CT;
					}

localvariabledeclaration             : type variabledeclarators
					{
						MyCompiler.Debug("P -> Lokale Variable angelegt!", 3);
						LocalVarDecl LVD = new LocalVarDecl();
						LVD.set_Type($1);
						LVD.declid=$2.declid;
						$$ = LVD;
					}

statementwithouttrailingsubstatement : block
				        {
						$$=$1;
					}
				  |  emptystatement
					{
						$$=$1;
					}
				  |  expressionstatement
					{
						$$=$1;
					}
				  |  returnstatement
					{
						$$=$1;
					}

ifthenstatement                   : IF '(' expression ')' statement
				        {
						IfStmt Ifst = new IfStmt();
						Ifst.set_Expr($3);
						Ifst.set_Then_block($5);
						$$=Ifst;
					}

ifthenelsestatement               : IF '('expression ')'statementnoshortif ELSE statement
				        {
						IfStmt IfstElst = new IfStmt();
						IfstElst.set_Expr($3);
						IfstElst.set_Then_block($5);
						IfstElst.set_Else_block($7);
						$$=IfstElst;
					}

whilestatement                    : WHILE '(' expression ')' statement
					{
						WhileStmt Whlst = new WhileStmt();
						Whlst.set_Expr($3);
						Whlst.set_Loop_block($5);
						$$=Whlst;
					}

assignmentexpression	          : conditionalexpression
					{
						$$=$1;
					}
				  |  assignment
					{
						$$=$1;
					}

emptystatement			  : ';'
					{
						EmptyStmt Empst = new EmptyStmt();
						$$=Empst;
					}

expressionstatement               : statementexpression ';'
					{
						$$=$1;
					}

returnstatement                   :  RETURN ';'
				        {
						Return ret = new Return();
						$$= ret;
					}
				  |  RETURN expression ';'
					{
						Return retexp = new Return();
						retexp.set_ReturnExpr($2);
						$$=retexp;
					}

statementnoshortif		 :statementwithouttrailingsubstatement
					{
						$$=$1;
					}
				 | ifthenelsestatementnoshortif
					{
						$$=$1;
					}
				 | whilestatementnoshortif
					{
						$$=$1;
					}

conditionalexpression            :conditionalorexpression
					{
						$$=$1;
					}
			//	 | conditionalorexpression '?' expression ':' conditionalexpression

assignment                       :lefthandside assignmentoperator assignmentexpression
					{
						MyCompiler.Debug("\nParser --> Zuweisung1!\n", 3);
						Assign Ass = new Assign();
						LocalOrFieldVar LOFV = new LocalOrFieldVar();
						LOFV.set_UsedId($1);
						if( $2 == null )
						{
							MyCompiler.Debug("\nParser --> Zuweisung1 --> " + $3 + " \n", 3);
							Ass.set_Expr( LOFV,$3 );
						}
						else
						{
							Binary Bin = new Binary();
							Bin.set_Expr1(LOFV);
							Bin.set_Operator($2);
							Bin.set_Expr2($3);
							MyCompiler.Debug("\nParser --> Zuweisung1 --> Binary\n", 3);
							Ass.set_Expr( LOFV, Bin );
						}
						$$=Ass;
					}
				 | lefthandside assignmentoperator classinstancecreationexpression
					{
						Assign Ass =new Assign();
						LocalOrFieldVar LOFV = new LocalOrFieldVar();
						LOFV.set_UsedId($1);
						if($2==null)
						{
							Ass.set_Expr(LOFV,$3);
						}
						else
						{
							 Binary Bin = new Binary();
							 Bin.set_Expr1(LOFV);
							 Bin.set_Operator($2);
							 Bin.set_Expr2($3);
							 Ass.set_Expr(LOFV,Bin);
						}
						$$=Ass;
					}

statementexpression              :assignment
					{
						$$=$1;
					}
				 | preincrementexpression
					{
						$$=$1;
					}
				 | predecrementexpression
					{
						$$=$1;
					}
				 | postincrementexpression
					{
						$$=$1;
					}
				 | postdecrementexpression
					{
						$$=$1;
					}
				 | methodinvocation
					{
						$$=$1;
					}
/*				 | classinstancecreationexpression
					{
						$$=$1;
					}
*/

ifthenelsestatementnoshortif     :IF '(' expression ')' statementnoshortif
				  ELSE statementnoshortif
				       {
						IfStmt IfElno = new IfStmt();
						IfElno.set_Expr($3);
						IfElno.set_Then_block($5);
						IfElno.set_Else_block($7);
						$$=IfElno;
					}

whilestatementnoshortif          :WHILE '(' expression ')' statementnoshortif
					{
						WhileStmt Whstno = new WhileStmt();
						Whstno.set_Expr($3);
						Whstno.set_Loop_block($5);
						$$=Whstno;
					}

conditionalorexpression          : conditionalandexpression
					{
						$$=$1;
					}
				 | conditionalorexpression LOGICALOR conditionalandexpression
					{
						Binary LogOr = new Binary();
			       			OrOp OrO = new OrOp();
						LogOr.set_Expr1($1);
						LogOr.set_Expr2($3);
						LogOr.set_Operator(OrO);
						$$=LogOr;
			       		}


lefthandside                     :name
					{
						$$=$1;
					}

assignmentoperator               : '='
					{
						$$=null;
					}
				 | TIMESEQUAL
					{
						TimesOp TEO = new TimesOp();
						$$=TEO;
					}
				 | DIVIDEEQUAL
					{
						DivideOp DEO = new DivideOp();
						$$=DEO;
					}
				 | MODULOEQUAL
					{
						ModuloOp MEO = new ModuloOp();
						$$=MEO;
					}
				 | PLUSEQUAL
					{
						PlusOp PEO = new PlusOp();
						$$=PEO;
					}
				 | MINUSEQUAL
					{
						MinusOp MEO = new MinusOp();
						$$=MEO;
					}
			//	 | SHIFTLEFTEQUAL
			//	 | SIGNEDSHIFTRIGHTEQUAL
			//       | UNSIGNEDSHIFTRIGHTEQUAL
			//       | ANDEQUAL
			//       | XOREQUAL
			//       | OREQUAL

preincrementexpression         :INCREMENT unaryexpression
					{
						PreIncExpr PRINC = new PreIncExpr();
						PRINC.set_Expr($2);
						$$=PRINC;
					}

predecrementexpression         :DECREMENT unaryexpression
					{
						PreDecExpr PRDEC = new PreDecExpr();
						PRDEC.set_Expr($2);
						$$=PRDEC;
					}

postincrementexpression        :postfixexpression INCREMENT
					{
						PostIncExpr PIE = new PostIncExpr();
						PIE.set_Expr($1);
						$$=PIE;
					}

postdecrementexpression        :postfixexpression DECREMENT
					{
						PostDecExpr PDE = new PostDecExpr();
						PDE.set_Expr($1);
						$$=PDE;
					}

methodinvocation               :name '(' ')'
					{
						MethodCall MC = new MethodCall();
						MC.set_UsedId($1);
						$$=MC;
					}
			       | name '('argumentlist')'
					{
						MethodCall MCarg = new MethodCall();
						MCarg.set_UsedId($1);
						MCarg.set_ArgumentList($3);
						$$=MCarg;
					}
			       | primary '.' IDENTIFIER '(' ')'
					{
						MethodCall MCpr = new MethodCall();
						$1.usedid.set_Name($3.getLexem());
						MCpr.set_UsedId($1.get_UsedId());
						$$=MCpr;
					}
			       | primary '.' IDENTIFIER	'('argumentlist ')'
					{
						MethodCall MCPA = new MethodCall();
						$1.usedid.set_Name($3.getLexem());
						MCPA.set_UsedId($1.get_UsedId());
						MCPA.set_ArgumentList($5);
						$$=MCPA;
					}
                          //   | SUPER '.' IDENTIFIER '(' ')'
			  //   | SUPER '.' IDENTIFIER '('argumentlist')'

classinstancecreationexpression : NEW classtype '(' ')'
					{
						NewClass NC = new NewClass();
						NC.set_UsedId($2);
						$$=NC;
					}
                               | NEW classtype '(' argumentlist ')'
					{
						NewClass NCarg = new NewClass();
						NCarg.set_UsedId($2);
						NCarg.set_ArgumentList($4);
						$$=NCarg;
					}

conditionalandexpression       : inclusiveorexpression
					{
						$$=$1;
					}
			       | conditionalandexpression LOGICALAND inclusiveorexpression
					{
						Binary And = new Binary();
						AndOp AndO = new AndOp();
						And.set_Expr1($1);
						And.set_Expr2($3);
						And.set_Operator(AndO);
						$$=And;
					}

/*
fieldaccess                    :primary '.' IDENTIFIER
			         | SUPER '.' IDENTIFIER
*/

unaryexpression		       : preincrementexpression
					{
						$$=$1;
					}
			       | predecrementexpression
					{
						$$=$1;
					}
			       | '+' unaryexpression
				     {
					PositivExpr POSEX=new PositivExpr();
					UnaryPlus UP= new UnaryPlus();
					POSEX.set_UnaryPlus(UP);
					POSEX.set_Expr($2);
					$$=POSEX;
				     }
			       | '-' unaryexpression
				     {
					NegativeExpr NEGEX=new NegativeExpr();
					UnaryMinus UM=new UnaryMinus();
					NEGEX.set_UnaryMinus(UM);
					NEGEX.set_Expr($2);
					$$=NEGEX;
				     }
			       | unaryexpressionnotplusminus
					{
						$$=$1;
					}

postfixexpression              :primary
					{
						$$=$1;
					}
			       | name
					{
						LocalOrFieldVar Postincexpr = new LocalOrFieldVar();
						Postincexpr.set_UsedId($1);
						$$=Postincexpr;
					}
			       | postincrementexpression
					{
						$$=$1;
					}
			       | postdecrementexpression
					{
						$$=$1;
					}

primary			       : primarynonewarray
					{
						$$=$1;
					}

inclusiveorexpression	       : exclusiveorexpression
					{
						$$=$1;
					}
			       | inclusiveorexpression '|' exclusiveorexpression

primarynonewarray	       : literal
					{
						$$=$1;
					}
			       | THIS
					{
						This T = new This();
						UsedId UT = new UsedId();
						UT.set_Name($1.getLexem());
						T.set_UsedId(UT);
						$$=T;
					}

			       | '('expression')'
				 	{
						$$=$2;
					}
/*
		               | classinstancecreationexpression
					{
						$$=$1;
					}
			       | fieldaccess
*/
			       | methodinvocation
					{
						$$=$1;
					}

unaryexpressionnotplusminus     : postfixexpression					{$$=$1;}
	                     // | '~' unaryexpression
				| '!' unaryexpression					{NotExpr NE=new NotExpr();
											 UnaryNot UN=new UnaryNot();
											 NE.set_UnaryNot(UN);
											 NE.set_Expr($2);
											 $$=NE;
											}
				| castexpression					{$$=$1;}

exclusiveorexpression           :andexpression 						{$$=$1;}
				| exclusiveorexpression '^' andexpression 		//{
											//
											//}

literal				: INTLITERAL						{IntLiteral IL = new IntLiteral();
											IL.set_Int($1.String2Int());
											$$ = IL;
											}

				| BOOLLITERAL						{BoolLiteral BL = new BoolLiteral();
											 BL.set_Bool($1.String2Bool());
											 $$ = BL;
											}
				| CHARLITERAL						{CharLiteral CL = new CharLiteral();
											CL.set_Char($1.CharInString());
											$$=CL;
											}
				| STRINGLITERAL
					{
						StringLiteral ST = new StringLiteral();
						ST.set_String($1.get_String());
						$$=ST;
					}
				| JNULL;
					{
						Null NN = new Null();
						$$=NN;
					}

castexpression			: '(' primitivetype ')' unaryexpression
					{
						CastExpr CaEx=new CastExpr();
						CaEx.set_Type($2);
						CaEx.set_Expr($4);
						$$=CaEx;
					}
 				//| '(' expression ')' unaryexpressionnotplusminus

andexpression                   :equalityexpression
					{
						$$=$1;
					}
				| andexpression '&' equalityexpression
					{
					}

equalityexpression              : relationalexpression
					{
						$$=$1;
					}
				| equalityexpression EQUAL relationalexpression
					{
						Binary EQ = new Binary();
						EqualOp EO = new EqualOp();
						EQ.set_Expr1($1);
						EQ.set_Expr2($3);
						EQ.set_Operator(EO);
						$$=EQ;
					}
				| equalityexpression NOTEQUAL relationalexpression
					{
						Binary NEQ = new Binary();
						NotEqualOp NEO = new NotEqualOp();
						NEQ.set_Expr1($1);
						NEQ.set_Expr2($3);
						NEQ.set_Operator(NEO);
						$$=NEQ;
					}

relationalexpression		: shiftexpression
					{
						$$=$1;
					}
				| relationalexpression '<' shiftexpression
					{
						Binary LO = new Binary();
						LessOp LOO = new LessOp();
						LO.set_Expr1($1);
						LO.set_Expr2($3);
						LO.set_Operator(LOO);
						$$=LO;
					}
				| relationalexpression '>' shiftexpression
					{
						Binary GO = new Binary();
						GreaterOp GOO = new GreaterOp();
						GO.set_Expr1($1);
						GO.set_Expr2($3);
						GO.set_Operator( GOO );
						$$=GO;
					}
				| relationalexpression LESSEQUAL shiftexpression
					{
						Binary LE = new Binary();
						LessEquOp LEO = new LessEquOp();
						LE.set_Expr1($1);
						LE.set_Expr2($3);
						LE.set_Operator(LEO);
						$$=LE;
					}
				| relationalexpression GREATEREQUAL shiftexpression
					{
						Binary GE = new Binary();
						GreaterEquOp GEO = new GreaterEquOp();
						GE.set_Expr1($1);
						GE.set_Expr2($3);
						GE.set_Operator(GEO);
						$$=GE;
					}
				| relationalexpression INSTANCEOF referencetype
					{
						InstanceOf ISO=new InstanceOf();
						ISO.set_Expr($1);
						ISO.set_Type($3);
						$$=ISO;
					}

shiftexpression			: additiveexpression
					{
						$$=$1;
					}

additiveexpression              :multiplicativeexpression
					{
						$$=$1;
					}
				| additiveexpression '+' multiplicativeexpression
					{
						Binary AD = new Binary();
						PlusOp PO = new PlusOp();
						AD.set_Expr1($1);
						AD.set_Expr2($3);
						AD.set_Operator(PO);
						$$=AD;
					}
				| additiveexpression '-' multiplicativeexpression
					{
						Binary MI = new Binary();
						MinusOp MO = new MinusOp();
						MI.set_Expr1($1);
						MI.set_Expr2($3);
						MI.set_Operator(MO);
						$$=MI;
					}

multiplicativeexpression	: unaryexpression
					{
						$$=$1;
					}
				| multiplicativeexpression '*' unaryexpression
					{
						Binary ML = new Binary();
					        TimesOp TO = new TimesOp();
						ML.set_Expr1($1);
						ML.set_Expr2($3);
						ML.set_Operator(TO);
						$$=ML;
					}
				| multiplicativeexpression '/' unaryexpression
				  {
					Binary DV = new Binary();
					DivideOp DO = new DivideOp();
					DV.set_Expr1($1);
					DV.set_Expr2($3);
					DV.set_Operator(DO);
					$$ = DV;
				  }
				| multiplicativeexpression '%' unaryexpression
				  {
					Binary MD = new Binary();
					ModuloOp MO = new ModuloOp();
					MD.set_Expr1($1);
					MD.set_Expr2($3);
					MD.set_Operator(MO);
					$$ =MD;
				  }

/* OTTH: Methodenparametertypen m<>ssen nicht mehr angegeben werden */

formalparameter     : variabledeclaratorid
					{
						MyCompiler.Debug("\nFunktionsdeklaration mit typlosen Parametern: " + $1.name, 3);

						FormalParameter FP = new FormalParameter();

						Type T = new TyploseVariable(""); /* otth: Name wird automatisch berechnet */
                        MyCompiler.Debug("\n--> berechneter Name: " + T.get_Type(), 3);

						FP.set_Type( T );
						FP.set_DeclId($1);

						$$=FP;
					}

%%