forked from JavaTX/JavaCompilerCore
2389 lines
68 KiB
Plaintext
2389 lines
68 KiB
Plaintext
|
%{
|
|||
|
|
|||
|
/*
|
|||
|
Backup von JavaParser.jay 10.April 17 Uhr
|
|||
|
*/
|
|||
|
|
|||
|
package mycompiler.myparser;
|
|||
|
|
|||
|
|
|||
|
import java.util.Vector;
|
|||
|
import mycompiler.myclass.FieldInitialization;
|
|||
|
import mycompiler.SourceFile;
|
|||
|
import mycompiler.AClassOrInterface;
|
|||
|
import mycompiler.myclass.Class;
|
|||
|
import mycompiler.myclass.ClassBody;
|
|||
|
import mycompiler.myclass.Constructor;
|
|||
|
import mycompiler.myclass.Constant;
|
|||
|
import mycompiler.myclass.ImportDeclarations;
|
|||
|
import mycompiler.myclass.DeclId;
|
|||
|
import mycompiler.myclass.ExceptionList;
|
|||
|
import mycompiler.myclass.FieldDecl;
|
|||
|
import mycompiler.myclass.FormalParameter;
|
|||
|
import mycompiler.myclass.InstVarDecl;
|
|||
|
import mycompiler.myclass.Method;
|
|||
|
import mycompiler.myclass.ParameterList;
|
|||
|
import mycompiler.myclass.UsedId;
|
|||
|
import mycompiler.myinterface.Interface;
|
|||
|
import mycompiler.myinterface.InterfaceBody;
|
|||
|
import mycompiler.mymodifier.Abstract;
|
|||
|
import mycompiler.mymodifier.Final;
|
|||
|
import mycompiler.mymodifier.Modifier;
|
|||
|
import mycompiler.mymodifier.Modifiers;
|
|||
|
import mycompiler.mymodifier.Private;
|
|||
|
import mycompiler.mymodifier.Protected;
|
|||
|
import mycompiler.mymodifier.Public;
|
|||
|
import mycompiler.mymodifier.Static;
|
|||
|
import mycompiler.myoperator.AndOp;
|
|||
|
import mycompiler.myoperator.DivideOp;
|
|||
|
import mycompiler.myoperator.EqualOp;
|
|||
|
import mycompiler.myoperator.GreaterEquOp;
|
|||
|
import mycompiler.myoperator.GreaterOp;
|
|||
|
import mycompiler.myoperator.LessEquOp;
|
|||
|
import mycompiler.myoperator.LessOp;
|
|||
|
import mycompiler.myoperator.MinusOp;
|
|||
|
import mycompiler.myoperator.ModuloOp;
|
|||
|
import mycompiler.myoperator.NotEqualOp;
|
|||
|
import mycompiler.myoperator.Operator;
|
|||
|
import mycompiler.myoperator.OrOp;
|
|||
|
import mycompiler.myoperator.PlusOp;
|
|||
|
import mycompiler.myoperator.TimesOp;
|
|||
|
import mycompiler.mystatement.ArgumentList;
|
|||
|
import mycompiler.mystatement.Assign;
|
|||
|
import mycompiler.mystatement.Binary;
|
|||
|
import mycompiler.mystatement.Block;
|
|||
|
import mycompiler.mystatement.BoolLiteral;
|
|||
|
import mycompiler.mystatement.FloatLiteral;
|
|||
|
import mycompiler.mystatement.DoubleLiteral;
|
|||
|
import mycompiler.mystatement.LongLiteral;
|
|||
|
import mycompiler.mystatement.CastExpr;
|
|||
|
import mycompiler.mystatement.CharLiteral;
|
|||
|
import mycompiler.mystatement.EmptyStmt;
|
|||
|
import mycompiler.mystatement.Expr;
|
|||
|
import mycompiler.mystatement.ExprStmt;
|
|||
|
import mycompiler.mystatement.IfStmt;
|
|||
|
import mycompiler.mystatement.InstanceOf;
|
|||
|
import mycompiler.mystatement.IntLiteral;
|
|||
|
import mycompiler.mystatement.Literal;
|
|||
|
import mycompiler.mystatement.InstVar;
|
|||
|
import mycompiler.mystatement.LocalOrFieldVar;
|
|||
|
import mycompiler.mystatement.LocalVarDecl;
|
|||
|
import mycompiler.mystatement.MethodCall;
|
|||
|
import mycompiler.mystatement.NegativeExpr;
|
|||
|
import mycompiler.mystatement.NewClass;
|
|||
|
import mycompiler.mystatement.NotExpr;
|
|||
|
import mycompiler.mystatement.Null;
|
|||
|
import mycompiler.mystatement.PositivExpr;
|
|||
|
import mycompiler.mystatement.PostDecExpr;
|
|||
|
import mycompiler.mystatement.PostIncExpr;
|
|||
|
import mycompiler.mystatement.PreDecExpr;
|
|||
|
import mycompiler.mystatement.PreIncExpr;
|
|||
|
import mycompiler.mystatement.Receiver;
|
|||
|
import mycompiler.mystatement.Return;
|
|||
|
import mycompiler.mystatement.Statement;
|
|||
|
import mycompiler.mystatement.StringLiteral;
|
|||
|
import mycompiler.mystatement.This;
|
|||
|
import mycompiler.mystatement.UnaryMinus;
|
|||
|
import mycompiler.mystatement.UnaryNot;
|
|||
|
import mycompiler.mystatement.UnaryPlus;
|
|||
|
import mycompiler.mystatement.WhileStmt;
|
|||
|
import mycompiler.mystatement.ForStmt;
|
|||
|
import mycompiler.mystatement.LambdaExpression;
|
|||
|
import mycompiler.mytype.BaseType;
|
|||
|
import mycompiler.mytype.BooleanType;
|
|||
|
import mycompiler.mytype.CharacterType;
|
|||
|
import mycompiler.mytype.GenericTypeVar;
|
|||
|
import mycompiler.mytype.BoundedGenericTypeVar;
|
|||
|
import mycompiler.mytype.IntegerType;
|
|||
|
import mycompiler.mytype.ParaList;
|
|||
|
import mycompiler.mytype.RefType;
|
|||
|
import mycompiler.mytype.Type;
|
|||
|
import mycompiler.mytype.TypePlaceholder;
|
|||
|
import mycompiler.mytype.Void;
|
|||
|
import mycompiler.mytype.WildcardType;
|
|||
|
import mycompiler.mytype.ExtendsWildcardType;
|
|||
|
import mycompiler.mytype.SuperWildcardType;
|
|||
|
import mycompiler.mytype.Pair;
|
|||
|
|
|||
|
public class JavaParser{
|
|||
|
public Vector path = new Vector();
|
|||
|
|
|||
|
//PL 05-07-30 eingefuegt. ANFANG
|
|||
|
private Vector<Type> containedTypes = new Vector<Type>();
|
|||
|
private Vector<UsedId> usedIdsToCheck = new Vector<UsedId>();
|
|||
|
//Vektor aller Typdeklarationen die in aktueller Klasse vorkommen.
|
|||
|
//wird nach Beendigung der Klasse des Attributs der jeweiligen
|
|||
|
//Klasse zugeordnet
|
|||
|
//nach dem Parsen wird mit wandleGeneric2RefType die
|
|||
|
//die RefTypes gesetzt.
|
|||
|
void initContainedTypes() {
|
|||
|
this.containedTypes = new Vector<Type>();
|
|||
|
}
|
|||
|
void initUsedIdsToCheck() {
|
|||
|
this.usedIdsToCheck = new Vector<UsedId>();
|
|||
|
}
|
|||
|
//PL 05-07-30 eingefuegt. ENDE
|
|||
|
|
|||
|
//LUAR 07-05-29 Anfang f<>r Wildcard Test
|
|||
|
public Vector<Pair> testPair = new Vector<Pair>();
|
|||
|
//LUAR 07-05-29 Ende
|
|||
|
%}
|
|||
|
|
|||
|
%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 <Token> FINAL
|
|||
|
%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 PACKAGE
|
|||
|
%token IMPORT
|
|||
|
%token INTERFACE
|
|||
|
%token IMPLEMENTS
|
|||
|
%token RETURN
|
|||
|
%token <Token> STATIC
|
|||
|
%token <Token> SUPER
|
|||
|
%token SWITCH
|
|||
|
%token <Token> THIS
|
|||
|
%token THROW
|
|||
|
%token <Token> THROWS
|
|||
|
%token TRY
|
|||
|
%token <Token> VOID
|
|||
|
%token WHILE
|
|||
|
%token <Token> INTLITERAL
|
|||
|
%token <Token> LONGLITERAL
|
|||
|
%token <Token> DOUBLELITERAL
|
|||
|
%token <Token> FLOATLITERAL
|
|||
|
%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
|
|||
|
%token LAMBDAASSIGNMENT
|
|||
|
|
|||
|
%type <Class> classdeclaration
|
|||
|
%type <Interface> interfacedeclaration
|
|||
|
%type <InterfaceBody> interfacebody
|
|||
|
%type <InterfaceBody> interfacememberdeclarations
|
|||
|
%type <FieldDecl> interfacememberdeclaration
|
|||
|
%type <Method> abstractmethoddeclaration
|
|||
|
%type <ClassBody> classbody
|
|||
|
%type <ClassAndParameter> classidentifier
|
|||
|
%type <InterfaceAndParameter> interfaceidentifier
|
|||
|
%type <Constant> constantdeclaration
|
|||
|
%type <FieldDecl> fielddeclaration
|
|||
|
%type <Method> methodheader
|
|||
|
%type <Method> methoddeclaration
|
|||
|
%type <Method> methoddeclarator
|
|||
|
%type <ClassBody> classbodydeclarations
|
|||
|
%type <FieldDecl> classbodydeclaration
|
|||
|
%type <FieldDecl> classmemberdeclaration
|
|||
|
%type <InstVarDecl> variabledeclarators
|
|||
|
%type <FieldInitialization> fielddeclarator;
|
|||
|
%type <DeclId> variabledeclarator
|
|||
|
%type <DeclId> variabledeclaratorid
|
|||
|
%type <UsedId> simplename
|
|||
|
%type <UsedId> qualifiedname
|
|||
|
%type <UsedId> importqualifiedname
|
|||
|
%type <UsedId> importdeclaration
|
|||
|
%type <ImportDeclarations> importdeclarations
|
|||
|
%type <UsedId> name
|
|||
|
%type <UsedId> super
|
|||
|
%type <UsedId> classtype
|
|||
|
%type <UsedId> classorinterfacetype
|
|||
|
%type <UsedId> interfacetype
|
|||
|
%type <InterfaceList> interfaces
|
|||
|
%type <InterfaceList> extendsinterfaces
|
|||
|
%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 <Block> lambdabody
|
|||
|
%type <LocalVarDecl> localvariabledeclarationstatement
|
|||
|
%type <LocalVarDecl> localvariabledeclaration
|
|||
|
%type <ExceptionList> throws
|
|||
|
%type <FormalParameter> formalparameter
|
|||
|
%type <ParameterList> formalparameterlist
|
|||
|
%type <ParameterList> lambdaexpressionparameter
|
|||
|
%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> lambdaexpression /*added by Andreas Stadelmeier*/
|
|||
|
%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 <ForStmt> forstatement
|
|||
|
%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 <GenericTypeVar> boundedMethodParameter;
|
|||
|
%type <GenericTypeVar> boundedClassParameter;
|
|||
|
%type <Vector> boundedclassidentifierlist //Vector<Type>
|
|||
|
%type <Vector> boundedMethodParameters; // Vector<GenericTypeVar>
|
|||
|
%type <ParaList> boundedClassParameters; // ParaList
|
|||
|
%type <UsedId> packagedeclaration
|
|||
|
%type <Assign> assignment
|
|||
|
%type <Operator> assignmentoperator
|
|||
|
%type <Operator> lambdaassignmentoperator /*added by Andreas Stadelmeier*/
|
|||
|
%type <UsedId> lefthandside
|
|||
|
%type <ArgumentList> argumentlist
|
|||
|
%type <MethodCall> methodinvocation
|
|||
|
%type <AClassOrInterface> typedeclaration
|
|||
|
%type <FieldDecl> constructordeclaration
|
|||
|
%type <Constructor> constructordeclarator
|
|||
|
%type <Block> constructorbody
|
|||
|
%type <Statement> explicitconstructorinvocation
|
|||
|
%type <Method> staticinitializer
|
|||
|
%type <CastExpr> castexpression
|
|||
|
%type <ParaList> paralist parameter
|
|||
|
%type <WildcardType> wildcardparameter
|
|||
|
%left ','
|
|||
|
%%
|
|||
|
|
|||
|
compilationunit : typedeclarations
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
/* |importdeclarations typedeclarations
|
|||
|
{
|
|||
|
$2.addImports($1);
|
|||
|
$$=$2;
|
|||
|
}
|
|||
|
| packagedeclaration importdeclarations typedeclarations
|
|||
|
{
|
|||
|
// SCJU: Package
|
|||
|
$3.setPackageName($1);
|
|||
|
$3.addImports($2);
|
|||
|
$$=$3;
|
|||
|
}
|
|||
|
| packagedeclaration typedeclarations
|
|||
|
{
|
|||
|
// SCJU: Package
|
|||
|
$2.setPackageName($1);
|
|||
|
$$=$2;
|
|||
|
}
|
|||
|
| type type compilationunit
|
|||
|
{
|
|||
|
this.testPair.add(new Pair($1,$2));
|
|||
|
$$=$3;
|
|||
|
}
|
|||
|
*/
|
|||
|
packagedeclaration : PACKAGE name ';' ;
|
|||
|
{
|
|||
|
// SCJU: Package
|
|||
|
$$ = $2;
|
|||
|
}
|
|||
|
|
|||
|
importdeclarations :importdeclaration
|
|||
|
{
|
|||
|
ImportDeclarations declarations=new ImportDeclarations();
|
|||
|
declarations.addElement($1);
|
|||
|
$$=declarations;
|
|||
|
}
|
|||
|
|importdeclarations importdeclaration
|
|||
|
{
|
|||
|
$1.addElement($2);
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
importdeclaration : IMPORT importqualifiedname ';'
|
|||
|
{
|
|||
|
$$=$2;
|
|||
|
}
|
|||
|
|
|||
|
typedeclarations :typedeclaration
|
|||
|
{
|
|||
|
SourceFile Scfile = new SourceFile();
|
|||
|
Scfile.addElement($1);
|
|||
|
$$=Scfile;
|
|||
|
}
|
|||
|
|typedeclarations typedeclaration
|
|||
|
{
|
|||
|
$1.addElement($2);
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
name :qualifiedname
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|simplename
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
typedeclaration :classdeclaration
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
/* | interfacedeclaration
|
|||
|
{
|
|||
|
// SCJU: Interface
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
*/
|
|||
|
|
|||
|
qualifiedname : name '.' IDENTIFIER
|
|||
|
{
|
|||
|
$1.set_Name($3.getLexem());
|
|||
|
$1.setOffset($1.getOffset());
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
importqualifiedname : name '.' IDENTIFIER
|
|||
|
{
|
|||
|
$1.set_Name($3.getLexem());
|
|||
|
$1.setOffset($1.getOffset());
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| name '.' '*'
|
|||
|
{
|
|||
|
$1.set_Name("*");
|
|||
|
$1.setOffset($1.getOffset());
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
simplename : IDENTIFIER
|
|||
|
{
|
|||
|
UsedId UI = new UsedId($1.getOffset());
|
|||
|
UI.set_Name( $1.getLexem() );
|
|||
|
UI.setOffset($1.getOffset());//hinzugef<65>gt hoth: 07.04.2006
|
|||
|
$$ = UI;
|
|||
|
}
|
|||
|
|
|||
|
classdeclaration : CLASS classidentifier classbody
|
|||
|
{
|
|||
|
// SCJU: Um das hier uebersichtlicher zu halten,
|
|||
|
// gibt es einen allumfassenden Konstruktor fuer Class
|
|||
|
// Parameter:
|
|||
|
// String name,
|
|||
|
// Modifiers mod,
|
|||
|
// ClassBody classbody,
|
|||
|
// Vector<Type> containedtypes,
|
|||
|
// UsedId superclass,
|
|||
|
// Vector<UsedId> SuperInterfaces,
|
|||
|
// Vector<Type> Parameterliste
|
|||
|
|
|||
|
$$ = new Class($2.getName(), null, $3, containedTypes, usedIdsToCheck, null, null, $2.getParaVector());
|
|||
|
this.initContainedTypes();
|
|||
|
this.initUsedIdsToCheck();
|
|||
|
}
|
|||
|
| modifiers CLASS classidentifier classbody
|
|||
|
{
|
|||
|
$$ = new Class($3.getName(), $1, $4, containedTypes,usedIdsToCheck, null, null, $3.getParaVector());
|
|||
|
this.initContainedTypes();
|
|||
|
this.initUsedIdsToCheck();
|
|||
|
}
|
|||
|
| CLASS classidentifier super classbody
|
|||
|
{
|
|||
|
$$ = new Class($2.getName(), null, $4, containedTypes,usedIdsToCheck, $3, null, $2.getParaVector());
|
|||
|
this.initContainedTypes();
|
|||
|
this.initUsedIdsToCheck();
|
|||
|
}
|
|||
|
| modifiers CLASS classidentifier super classbody
|
|||
|
{
|
|||
|
$$ = new Class($3.getName(), $1, $5, containedTypes, usedIdsToCheck, $4, null, $3.getParaVector());
|
|||
|
this.initContainedTypes();
|
|||
|
this.initUsedIdsToCheck();
|
|||
|
}
|
|||
|
///* auskommentiert von Andreas Stadelmeier A10023
|
|||
|
| CLASS classidentifier interfaces classbody
|
|||
|
{
|
|||
|
$$ = new Class($2.getName(), null, $4, containedTypes, usedIdsToCheck, null, $3.getVector(), $2.getParaVector());
|
|||
|
this.initContainedTypes();
|
|||
|
this.initUsedIdsToCheck();
|
|||
|
}
|
|||
|
| modifiers CLASS classidentifier interfaces classbody
|
|||
|
{
|
|||
|
$$ = new Class($3.getName(), $1, $5, containedTypes, usedIdsToCheck, null, $4.getVector(), $3.getParaVector());
|
|||
|
this.initContainedTypes();
|
|||
|
this.initUsedIdsToCheck();
|
|||
|
}
|
|||
|
| CLASS classidentifier super interfaces classbody
|
|||
|
{
|
|||
|
$$ = new Class($2.getName(), null, $5, containedTypes,usedIdsToCheck, $3, $4.getVector(), $2.getParaVector());
|
|||
|
this.initContainedTypes();
|
|||
|
this.initUsedIdsToCheck();
|
|||
|
}
|
|||
|
| modifiers CLASS classidentifier super interfaces classbody
|
|||
|
{
|
|||
|
$$ = new Class($3.getName(), $1, $6, containedTypes, usedIdsToCheck, $4, $5.getVector(), $3.getParaVector());
|
|||
|
this.initContainedTypes();
|
|||
|
this.initUsedIdsToCheck();
|
|||
|
}
|
|||
|
//*/
|
|||
|
interfaceidentifier : IDENTIFIER
|
|||
|
{
|
|||
|
// HOTI
|
|||
|
// Verbindet den Namen eines Interfaces mit einer optionalen Parameterliste
|
|||
|
$$ = new InterfaceAndParameter($1.getLexem());
|
|||
|
}
|
|||
|
| IDENTIFIER '<' boundedClassParameters '>'
|
|||
|
{
|
|||
|
$$ = new InterfaceAndParameter($1.getLexem(), $3);
|
|||
|
}
|
|||
|
|
|||
|
classidentifier : IDENTIFIER
|
|||
|
{
|
|||
|
// SCJU: Hilfskonstrukt, um die Grammatik ueberschaubar zu halten
|
|||
|
// Verbindet den Namen einer Klasse mit einer optionalen Parameterliste
|
|||
|
$$ = new ClassAndParameter($1.getLexem());
|
|||
|
}
|
|||
|
| IDENTIFIER '<' boundedClassParameters '>'
|
|||
|
{
|
|||
|
$$ = new ClassAndParameter($1.getLexem(), $3);
|
|||
|
}
|
|||
|
|
|||
|
interfacedeclaration: INTERFACE interfaceidentifier interfacebody
|
|||
|
{
|
|||
|
// SCJU: Interface
|
|||
|
Interface ic = new Interface($2.getName());
|
|||
|
ic.setParaList($2.getParaVector());
|
|||
|
ic.setInterfaceBody($3);
|
|||
|
ic.setContainedTypes(containedTypes);
|
|||
|
initContainedTypes();
|
|||
|
$$ = ic;
|
|||
|
}
|
|||
|
| modifiers INTERFACE interfaceidentifier interfacebody
|
|||
|
{
|
|||
|
Interface ic = new Interface($3.getName(), $1);
|
|||
|
ic.setInterfaceBody($4);
|
|||
|
ic.setParaList($3.getParaVector());
|
|||
|
ic.setContainedTypes(containedTypes);
|
|||
|
initContainedTypes();
|
|||
|
$$ = ic;
|
|||
|
}
|
|||
|
| INTERFACE interfaceidentifier extendsinterfaces interfacebody
|
|||
|
{
|
|||
|
Interface ic = new Interface($2.getName());
|
|||
|
ic.setParaList($2.getParaVector());
|
|||
|
ic.setSuperInterfaces($3.getVector());
|
|||
|
ic.setInterfaceBody($4);
|
|||
|
ic.setContainedTypes(containedTypes);
|
|||
|
initContainedTypes();
|
|||
|
$$ = ic;
|
|||
|
}
|
|||
|
| modifiers INTERFACE interfaceidentifier extendsinterfaces interfacebody ;
|
|||
|
{
|
|||
|
Interface ic = new Interface($3.getName(), $1);
|
|||
|
ic.setParaList($3.getParaVector());
|
|||
|
ic.setSuperInterfaces($4.getVector());
|
|||
|
ic.setInterfaceBody($5);
|
|||
|
ic.setContainedTypes(containedTypes);
|
|||
|
initContainedTypes();
|
|||
|
$$ = ic;
|
|||
|
}
|
|||
|
|
|||
|
paralist : IDENTIFIER
|
|||
|
{
|
|||
|
ParaList pl = new ParaList();
|
|||
|
/* #JB# 05.04.2005 */
|
|||
|
/* ########################################################### */
|
|||
|
pl.getParalist().addElement(new GenericTypeVar($1.getLexem(), $1.getOffset()));
|
|||
|
//pl.getParalist().addElement( new TypePlaceholder($1.getLexem()) );
|
|||
|
/* ########################################################### */
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug( "IDENTIFIER --> Paralist f<>r " + $1.getLexem() + " TV");
|
|||
|
$$ = pl;
|
|||
|
}
|
|||
|
| IDENTIFIER '<' paralist '>'
|
|||
|
{
|
|||
|
ParaList pl = new ParaList();
|
|||
|
RefType t = new RefType( $1.getLexem(),$1.getOffset() );
|
|||
|
t.set_ParaList( $3.get_ParaList() );
|
|||
|
pl.getParalist().addElement(t);
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug( "IDENTIFIER '<' paralist '>' --> Paralist f<>r " + $1.getLexem() + ": RefType");
|
|||
|
$$ = pl;
|
|||
|
}
|
|||
|
| wildcardparameter
|
|||
|
{
|
|||
|
ParaList pl = new ParaList();
|
|||
|
pl.getParalist().addElement($1);
|
|||
|
$$ = pl;
|
|||
|
}
|
|||
|
| paralist ',' IDENTIFIER
|
|||
|
{
|
|||
|
|
|||
|
/* #JB# 05.04.2005 */
|
|||
|
/* ########################################################### */
|
|||
|
$1.getParalist().addElement(new GenericTypeVar($3.getLexem(),$3.getOffset()));
|
|||
|
//$1.getParalist().addElement(new TypePlaceholder($3.getLexem()));
|
|||
|
/* ########################################################### */
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug( "paralist ',' IDENTIFIER --> Paralist f<>r " + $3.getLexem() + ": TV");
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug( "paralist: " + $1.getParalist());
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
| paralist ',' IDENTIFIER '<' paralist '>'
|
|||
|
{
|
|||
|
RefType t = new RefType( $3.getLexem() ,$3.getOffset() );
|
|||
|
t.set_ParaList( $5.get_ParaList() );
|
|||
|
$1.getParalist().addElement(t);
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug( "paralist ',' IDENTIFIER '<' paralist '>' --> Paralist f<>r " + $3.getLexem() + ": RefType");
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| paralist ',' wildcardparameter
|
|||
|
{
|
|||
|
$1.getParalist().addElement($3);
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
wildcardparameter : '?'
|
|||
|
{
|
|||
|
//Luar 29.11.06 Offset auf -1, da keine Angabe vorhanden
|
|||
|
WildcardType wc = new WildcardType(-1);
|
|||
|
$$ = wc;
|
|||
|
}
|
|||
|
| '?' EXTENDS referencetype
|
|||
|
{
|
|||
|
ExtendsWildcardType ewc = new ExtendsWildcardType($2.getOffset(),$3);
|
|||
|
$$ = ewc;
|
|||
|
}
|
|||
|
| '?' SUPER referencetype
|
|||
|
{
|
|||
|
SuperWildcardType swc = new SuperWildcardType($2.getOffset(),$3);
|
|||
|
$$ = swc;
|
|||
|
}
|
|||
|
|
|||
|
classbody : '{' '}'
|
|||
|
{
|
|||
|
ClassBody CB = new ClassBody();
|
|||
|
$$ = CB;
|
|||
|
}
|
|||
|
|
|||
|
| '{' classbodydeclarations '}'
|
|||
|
{
|
|||
|
$$ = $2;
|
|||
|
}
|
|||
|
|
|||
|
modifiers :modifier
|
|||
|
{
|
|||
|
Modifiers Mod = new Modifiers();
|
|||
|
Mod.addModifier($1);
|
|||
|
$$ = Mod;
|
|||
|
}
|
|||
|
|modifiers modifier
|
|||
|
{
|
|||
|
$1.addModifier($2);
|
|||
|
$$ = $1;
|
|||
|
}
|
|||
|
|
|||
|
super :EXTENDS classtype
|
|||
|
{
|
|||
|
$$ = $2;
|
|||
|
}
|
|||
|
|
|||
|
interfaces : IMPLEMENTS interfacetype
|
|||
|
{
|
|||
|
// SCJU: Interface
|
|||
|
InterfaceList il = new InterfaceList();
|
|||
|
il.addInterface($2);
|
|||
|
$$ = il;
|
|||
|
}
|
|||
|
| interfaces ',' interfacetype ;
|
|||
|
{
|
|||
|
$1.addInterface($3);
|
|||
|
$$ = $1;
|
|||
|
}
|
|||
|
|
|||
|
interfacebody : '{' '}'
|
|||
|
{
|
|||
|
// SCJU: Interface
|
|||
|
$$ = new InterfaceBody();
|
|||
|
}
|
|||
|
| '{' interfacememberdeclarations '}'
|
|||
|
{
|
|||
|
$$ = $2;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
|
|||
|
extendsinterfaces : EXTENDS interfacetype
|
|||
|
{
|
|||
|
// SCJU: Interface
|
|||
|
InterfaceList il = new InterfaceList();
|
|||
|
il.addInterface($2);
|
|||
|
$$ = il;
|
|||
|
}
|
|||
|
| extendsinterfaces ',' interfacetype ;
|
|||
|
{
|
|||
|
$1.addInterface($3);
|
|||
|
$$ = $1;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
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;
|
|||
|
}
|
|||
|
| FINAL
|
|||
|
{ Final fin = new Final();
|
|||
|
$$ = fin;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
classtype : classorinterfacetype
|
|||
|
{
|
|||
|
//PL 05-07-30 eingefuegt containedTypes ANFANG
|
|||
|
RefType RT = new RefType(-1);
|
|||
|
//RT.set_UsedId($1);
|
|||
|
//RT.setName(RT.get_UsedId().get_Name_1Element());
|
|||
|
RT.set_ParaList($1.get_RealParaList());
|
|||
|
RT.setName($1.get_Name_1Element());
|
|||
|
containedTypes.addElement(RT);
|
|||
|
//PL 05-07-30 eingefuegt containedTypes ENDE
|
|||
|
|
|||
|
$$ = $1;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
interfacememberdeclarations : interfacememberdeclaration
|
|||
|
{
|
|||
|
// SCJU: Interface
|
|||
|
InterfaceBody ib = new InterfaceBody();
|
|||
|
ib.addElement($1);
|
|||
|
$$ = ib;
|
|||
|
}
|
|||
|
| interfacememberdeclarations interfacememberdeclaration ;
|
|||
|
{
|
|||
|
$1.addElement($2);
|
|||
|
$$ = $1;
|
|||
|
}
|
|||
|
|
|||
|
interfacetype : classorinterfacetype ;
|
|||
|
{
|
|||
|
// SCJU: Interfaces
|
|||
|
$$ = $1;
|
|||
|
}
|
|||
|
|
|||
|
classbodydeclaration : classmemberdeclaration
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
///* auskommentiert von Andreas Stadelmeier a10023
|
|||
|
| staticinitializer
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| constructordeclaration
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
//*/
|
|||
|
classorinterfacetype : simplename parameter
|
|||
|
{
|
|||
|
if ($2 != null) {
|
|||
|
$1.set_ParaList($2.get_ParaList());
|
|||
|
|
|||
|
/* otth: originale (also diese) Parameterliste retten */
|
|||
|
((UsedId)$1).vParaOrg = new Vector<Type>( $2.get_ParaList() );
|
|||
|
}
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
/* PL 05-07-28 erg<72>nzt, weil jeder classorinterfacetype auch parametrisiert sein kann */
|
|||
|
parameter : { $$ = null; }
|
|||
|
| '<'paralist'>'
|
|||
|
{
|
|||
|
$$ = $2;
|
|||
|
}
|
|||
|
|
|||
|
interfacememberdeclaration : constantdeclaration
|
|||
|
{
|
|||
|
// SCJU: Interfaces, Spezialform Konstantendef.
|
|||
|
$$ = $1;
|
|||
|
}
|
|||
|
| abstractmethoddeclaration
|
|||
|
{
|
|||
|
$$ = $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.addModifier(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;
|
|||
|
}
|
|||
|
|
|||
|
constantdeclaration : modifiers type IDENTIFIER '=' expression';' ;
|
|||
|
{
|
|||
|
// SCJU: Interface
|
|||
|
Constant c = new Constant($3.getLexem(), $1);
|
|||
|
c.setType($2);
|
|||
|
c.setValue($5);
|
|||
|
$$ = c;
|
|||
|
}
|
|||
|
|
|||
|
abstractmethoddeclaration : methodheader ';' ;
|
|||
|
{
|
|||
|
// SCJU: Interface
|
|||
|
$$ = $1;
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
added by Andreas Stadelmeier, a10023
|
|||
|
Bei Lokalen Variablen ist eine initialisierung der Variablen w<>hrend der Deklarisierung nicht erlaubt.
|
|||
|
Beispiel: var = 2;
|
|||
|
Bei einer lokalen Variable l<>sst sich hier nicht ermitteln ob die Variable deklariert werden soll oder bereits deklariert wurde und ihr nur ein Wert zugewiesen werden soll.
|
|||
|
Dieses Problem ist bei Feldern nicht der Fall.
|
|||
|
*/
|
|||
|
fielddeclarator : variabledeclarator '=' expression
|
|||
|
{
|
|||
|
FieldInitialization ret = new FieldInitialization();
|
|||
|
ret.set_DeclId($1);
|
|||
|
ret.setWert($3);
|
|||
|
$$=ret;
|
|||
|
}
|
|||
|
|
|||
|
fielddeclaration : fielddeclarator ';'
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| type fielddeclarator
|
|||
|
{
|
|||
|
$2.setType($1);
|
|||
|
$$=$2;
|
|||
|
}
|
|||
|
|
|
|||
|
variabledeclarators ';'
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|
|||
|
type variabledeclarators ';'
|
|||
|
{
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("T->Parser->fielddeclaration ...: type " + $1);
|
|||
|
$2.setType($1);
|
|||
|
$$ = $2;
|
|||
|
}
|
|||
|
|
|||
|
| modifiers type variabledeclarators ';'
|
|||
|
{
|
|||
|
$3.setType($2);
|
|||
|
for(int i=0;i<($3.getDeclIdVector().size());i++)
|
|||
|
{
|
|||
|
$3.getDeclIdVector().elementAt(i).modifiers=$1;
|
|||
|
}
|
|||
|
$$ = $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.setParameterList($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;
|
|||
|
}
|
|||
|
|
|||
|
boundedClassParameter : boundedMethodParameter
|
|||
|
{
|
|||
|
$$ = $1;
|
|||
|
}
|
|||
|
|
|||
|
boundedClassParameters : boundedClassParameter
|
|||
|
{
|
|||
|
ParaList p = new ParaList();
|
|||
|
p.add_ParaList($1);
|
|||
|
$$=p;
|
|||
|
}
|
|||
|
| boundedClassParameters ',' boundedClassParameter
|
|||
|
{
|
|||
|
$1.add_ParaList($3);
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
// returns GenericTypeVar
|
|||
|
boundedMethodParameter : IDENTIFIER
|
|||
|
{
|
|||
|
$$=new GenericTypeVar($1.getLexem(),$1.getOffset());
|
|||
|
}
|
|||
|
| IDENTIFIER EXTENDS boundedclassidentifierlist
|
|||
|
{
|
|||
|
BoundedGenericTypeVar gtv=new BoundedGenericTypeVar($1.getLexem(),$1.getOffset());
|
|||
|
gtv.setBounds($3);
|
|||
|
$$=gtv;
|
|||
|
}
|
|||
|
// returns Vector<Type>
|
|||
|
boundedclassidentifierlist : referencetype
|
|||
|
{
|
|||
|
Vector<Type> vec=new Vector<Type>();
|
|||
|
vec.addElement($1);
|
|||
|
containedTypes.addElement($1);
|
|||
|
$$=vec;
|
|||
|
}
|
|||
|
| boundedclassidentifierlist '&' referencetype
|
|||
|
{
|
|||
|
$1.addElement($3);
|
|||
|
containedTypes.addElement($3);
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
// returns Vector<Type>
|
|||
|
boundedMethodParameters : boundedMethodParameter
|
|||
|
{
|
|||
|
Vector<Type> vec=new Vector<Type>();
|
|||
|
vec.addElement($1);
|
|||
|
$$=vec;
|
|||
|
}
|
|||
|
| boundedMethodParameters ',' boundedMethodParameter
|
|||
|
{
|
|||
|
$1.addElement($3);
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
// returns Method
|
|||
|
methodheader :'<' boundedMethodParameters '>' type methoddeclarator
|
|||
|
{
|
|||
|
$5.setReturnType($4);
|
|||
|
$5.setGenericMethodParameters($2);
|
|||
|
$$=$5;
|
|||
|
}
|
|||
|
| type methoddeclarator
|
|||
|
{
|
|||
|
$2.setReturnType($1);
|
|||
|
$$=$2;
|
|||
|
}
|
|||
|
| modifiers type methoddeclarator
|
|||
|
{
|
|||
|
$3.set_Modifiers($1);
|
|||
|
$3.setReturnType($2);
|
|||
|
$$=$3;
|
|||
|
}
|
|||
|
| modifiers '<' boundedMethodParameters '>' type methoddeclarator
|
|||
|
{
|
|||
|
$6.set_Modifiers($1);
|
|||
|
$6.setGenericMethodParameters($3);
|
|||
|
$6.setReturnType($5);
|
|||
|
$$=$6;
|
|||
|
}
|
|||
|
| type methoddeclarator throws
|
|||
|
{
|
|||
|
$2.setReturnType($1);
|
|||
|
$2.set_ExceptionList($3);
|
|||
|
$$=$2;
|
|||
|
}
|
|||
|
| '<' boundedMethodParameters '>' type methoddeclarator throws
|
|||
|
{
|
|||
|
$5.setGenericMethodParameters($2);
|
|||
|
$5.setReturnType($4);
|
|||
|
$5.set_ExceptionList($6);
|
|||
|
$$=$5;
|
|||
|
}
|
|||
|
| modifiers type methoddeclarator throws
|
|||
|
{
|
|||
|
$3.set_Modifiers($1);
|
|||
|
$3.setReturnType($2);
|
|||
|
$3.set_ExceptionList($4);
|
|||
|
$$=$3;
|
|||
|
}
|
|||
|
| modifiers '<' boundedMethodParameters '>' type methoddeclarator throws
|
|||
|
{
|
|||
|
$6.set_Modifiers($1);
|
|||
|
$6.setGenericMethodParameters($3);
|
|||
|
$6.setReturnType($5);
|
|||
|
$6.set_ExceptionList($7);
|
|||
|
$$=$6;
|
|||
|
}
|
|||
|
| VOID methoddeclarator
|
|||
|
{
|
|||
|
Void Voit = new Void($1.getOffset());
|
|||
|
$2.setReturnType(Voit);
|
|||
|
$$=$2;
|
|||
|
}
|
|||
|
| modifiers VOID methoddeclarator
|
|||
|
{
|
|||
|
Void voit = new Void($2.getOffset());
|
|||
|
$3.set_Modifiers($1);
|
|||
|
$3.setReturnType(voit);
|
|||
|
$$=$3;
|
|||
|
}
|
|||
|
| VOID methoddeclarator throws
|
|||
|
{
|
|||
|
Void voyt = new Void($1.getOffset());
|
|||
|
$2.setReturnType(voyt);
|
|||
|
$2.set_ExceptionList($3);
|
|||
|
$$=$2;
|
|||
|
}
|
|||
|
| modifiers VOID methoddeclarator throws
|
|||
|
{
|
|||
|
Void voyd = new Void($2.getOffset());
|
|||
|
$3.set_Modifiers($1);
|
|||
|
$3.setReturnType(voyd);
|
|||
|
$3.set_ExceptionList($4);
|
|||
|
$$=$3;
|
|||
|
}
|
|||
|
| '<' boundedMethodParameters '>' VOID methoddeclarator
|
|||
|
{
|
|||
|
Void Voit = new Void($4.getOffset());
|
|||
|
$5.setReturnType(Voit);
|
|||
|
$5.setGenericMethodParameters($2);
|
|||
|
$$=$5;
|
|||
|
}
|
|||
|
| modifiers '<' boundedMethodParameters '>' VOID methoddeclarator
|
|||
|
{
|
|||
|
Void voit = new Void($5.getOffset());
|
|||
|
$6.set_Modifiers($1);
|
|||
|
$6.setReturnType(voit);
|
|||
|
$6.setGenericMethodParameters($3);
|
|||
|
$$=$6;
|
|||
|
}
|
|||
|
| '<' boundedMethodParameters '>' VOID methoddeclarator throws
|
|||
|
{
|
|||
|
Void voyt = new Void($4.getOffset());
|
|||
|
$5.setReturnType(voyt);
|
|||
|
$5.set_ExceptionList($6);
|
|||
|
$5.setGenericMethodParameters($2);
|
|||
|
$$=$5;
|
|||
|
}
|
|||
|
| modifiers '<' boundedMethodParameters '>' VOID methoddeclarator throws
|
|||
|
{
|
|||
|
Void voyd = new Void($5.getOffset());
|
|||
|
$6.set_Modifiers($1);
|
|||
|
$6.setReturnType(voyd);
|
|||
|
$6.set_ExceptionList($7);
|
|||
|
$6.setGenericMethodParameters($3);
|
|||
|
$$=$6;
|
|||
|
}
|
|||
|
|
|||
|
| methoddeclarator
|
|||
|
{
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) $1.setReturnType(TypePlaceholder.fresh());
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| '<' boundedMethodParameters '>' methoddeclarator
|
|||
|
{
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) $4.setReturnType(TypePlaceholder.fresh());
|
|||
|
$4.setGenericMethodParameters($2);
|
|||
|
$$=$4;
|
|||
|
}
|
|||
|
|
|||
|
| modifiers methoddeclarator
|
|||
|
{
|
|||
|
$2.set_Modifiers($1);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) $2.setReturnType(TypePlaceholder.fresh());
|
|||
|
$$=$2;
|
|||
|
}
|
|||
|
| methoddeclarator throws
|
|||
|
{
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) $1.setReturnType(TypePlaceholder.fresh());
|
|||
|
$1.set_ExceptionList($2);
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| modifiers methoddeclarator throws
|
|||
|
{
|
|||
|
$2.set_Modifiers($1);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) $2.setReturnType(TypePlaceholder.fresh());
|
|||
|
$2.set_ExceptionList($3);
|
|||
|
$$=$2;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
type : primitivetype
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|primitivetype '[' ']'
|
|||
|
{
|
|||
|
$1.setArray(true);
|
|||
|
}
|
|||
|
|referencetype
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|referencetype '[' ']'
|
|||
|
{
|
|||
|
$1.setArray(true);
|
|||
|
}
|
|||
|
variabledeclarators : variabledeclarator
|
|||
|
{
|
|||
|
InstVarDecl IVD = new InstVarDecl();
|
|||
|
IVD.getDeclIdVector().addElement( $1 );
|
|||
|
$$ = IVD;
|
|||
|
}
|
|||
|
| variabledeclarators ',' variabledeclarator
|
|||
|
{
|
|||
|
$1.getDeclIdVector().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($1.getOffset(),$1.getLexem().length());
|
|||
|
$$=THCON;
|
|||
|
}
|
|||
|
|THIS '(' argumentlist ')' ';'
|
|||
|
{
|
|||
|
This THCONargl = new This($1.getOffset(),$1.getLexem().length());
|
|||
|
THCONargl.set_ArgumentList($3);
|
|||
|
$$=THCONargl;
|
|||
|
}
|
|||
|
// |SUPER '(' ')' ';'
|
|||
|
// |SUPER '(' argumentlist ')' ';'
|
|||
|
|
|||
|
classtypelist : classtype
|
|||
|
{
|
|||
|
RefType RT = new RefType(-1);
|
|||
|
RT.set_UsedId($1);
|
|||
|
RT.setName(RT.get_UsedId().get_Name_1Element());
|
|||
|
$$=RT;
|
|||
|
}
|
|||
|
| classtypelist ',' classtype
|
|||
|
{
|
|||
|
$1.set_UsedId($3);
|
|||
|
$1.setName($1.get_UsedId().get_Name_1Element());
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
methoddeclarator :IDENTIFIER '(' ')'
|
|||
|
{
|
|||
|
Method met = new Method();
|
|||
|
/* #JB# 10.04.2005 */
|
|||
|
/* ########################################################### */
|
|||
|
met.setLineNumber($1.getLineNumber());
|
|||
|
met.setOffset($1.getOffset());//hinzugef<65>gt hoth: 07.04.2006
|
|||
|
/* ########################################################### */
|
|||
|
DeclId DImethod = new DeclId();
|
|||
|
DImethod.set_Name($1.getLexem());
|
|||
|
met.set_DeclId(DImethod);
|
|||
|
$$ = met;
|
|||
|
}
|
|||
|
|IDENTIFIER '(' formalparameterlist ')'
|
|||
|
{
|
|||
|
Method met_para = new Method();
|
|||
|
/* #JB# 10.04.2005 */
|
|||
|
/* ########################################################### */
|
|||
|
met_para.setLineNumber($1.getLineNumber());
|
|||
|
met_para.setOffset($1.getOffset());//hinzugef<65>gt hoth: 07.04.2006
|
|||
|
/* ########################################################### */
|
|||
|
DeclId Dimet_para = new DeclId();
|
|||
|
Dimet_para.set_Name($1.getLexem());
|
|||
|
met_para.set_DeclId(Dimet_para);
|
|||
|
met_para.setParameterList($3);
|
|||
|
$$ = met_para;
|
|||
|
}
|
|||
|
|
|||
|
primitivetype :BOOLEAN
|
|||
|
{
|
|||
|
BooleanType BT = new BooleanType();
|
|||
|
/* #JB# 05.04.2005 */
|
|||
|
/* ########################################################### */
|
|||
|
//BT.setName($1.getLexem());
|
|||
|
/* ########################################################### */
|
|||
|
$$=BT;
|
|||
|
}
|
|||
|
|numerictype
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
referencetype :classorinterfacetype
|
|||
|
{
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("T->Parser->referenctype: " + $1);
|
|||
|
RefType RT = new RefType($1.getOffset());
|
|||
|
|
|||
|
//ausgetauscht PL 05-07-30
|
|||
|
//RT.set_UsedId($1);
|
|||
|
//RT.setName(RT.get_UsedId().get_Name_1Element());
|
|||
|
RT.set_ParaList($1.get_RealParaList());
|
|||
|
RT.setName($1.getQualifiedName());
|
|||
|
|
|||
|
|
|||
|
//PL 05-07-30 eingefuegt containedTypes ANFANG
|
|||
|
containedTypes.addElement(RT);
|
|||
|
//PL 05-07-30 eingefuegt containedTypes ENDE
|
|||
|
|
|||
|
$$=RT;
|
|||
|
}
|
|||
|
/* 05-07-28 PL Parameterdeklarationen zur classorinterfacetype verschoben */
|
|||
|
|
|||
|
variabledeclarator : variabledeclaratorid
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
/* auskommentiert von Andreas Stadelmeier, a10023:
|
|||
|
eine Variable mit Initialisierung wird sowieso nicht geparst.
|
|||
|
| variabledeclaratorid '=' variableinitializer
|
|||
|
{
|
|||
|
$1.set_Wert($3);
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
*/
|
|||
|
/* 05-07-28 PL auskommentiert
|
|||
|
wird nicht ben<65>tigt aufgrund neuer classorinterfacetype declaration
|
|||
|
| '<' paralist'>' variabledeclaratorid '=' variableinitializer
|
|||
|
{
|
|||
|
$4.set_Wert($6);
|
|||
|
$4.set_Paratyp($2.get_ParaList());
|
|||
|
$$=$4;
|
|||
|
}
|
|||
|
*/
|
|||
|
blockstatement :localvariabledeclarationstatement
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|statement
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
formalparameter : type variabledeclaratorid
|
|||
|
{
|
|||
|
FormalParameter FP = new FormalParameter();
|
|||
|
FP.setType($1);
|
|||
|
FP.set_DeclId($2);
|
|||
|
$$=FP;
|
|||
|
}
|
|||
|
|
|||
|
/* otth: Methodenargumente koennen hiermit auch polymorph sein. */
|
|||
|
/* 05-07-28 PL auskommentiert
|
|||
|
wird nicht ben<65>tigt aufgrund neuer classorinterfacetype declaration
|
|||
|
| type '<'paralist'>' variabledeclaratorid
|
|||
|
{
|
|||
|
Parameterliste setzen
|
|||
|
$5.set_Paratyp($3.get_ParaList());
|
|||
|
|
|||
|
FormalParameter FP = new FormalParameter();
|
|||
|
FP.setType($1);
|
|||
|
FP.set_DeclId($5);
|
|||
|
$$=FP;
|
|||
|
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("P->Polymorphes Methodenargument hinzugefuegt: Name = " + $5.get_Name() + " Typ = " + $1.getName());
|
|||
|
}
|
|||
|
*/
|
|||
|
|
|||
|
| variabledeclaratorid
|
|||
|
{
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("\nFunktionsdeklaration mit typlosen Parametern: " + $1.name);
|
|||
|
|
|||
|
FormalParameter FP = new FormalParameter();
|
|||
|
|
|||
|
// #JB# 31.03.2005
|
|||
|
// ###########################################################
|
|||
|
Type T = TypePlaceholder.fresh();
|
|||
|
// Type T = new TypePlaceholder(""); /* otth: Name wird automatisch berechnet */
|
|||
|
// ###########################################################
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("\n--> berechneter Name: " + T.getName());
|
|||
|
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) FP.setType( T );
|
|||
|
FP.set_DeclId($1);
|
|||
|
|
|||
|
$$=FP;
|
|||
|
}
|
|||
|
|
|||
|
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();
|
|||
|
/* #JB# 10.04.2005 */
|
|||
|
/* ########################################################### */
|
|||
|
DI.setLineNumber($1.getLineNumber());
|
|||
|
DI.setOffset($1.getOffset());//hinzugef<65>gt hoth: 07.04.2006
|
|||
|
/* ########################################################### */
|
|||
|
DI.set_Name($1.getLexem());
|
|||
|
$$=DI;
|
|||
|
}
|
|||
|
|
|||
|
variableinitializer :expression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
localvariabledeclarationstatement :localvariabledeclaration ';'
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
statement :statementwithouttrailingsubstatement
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|ifthenstatement
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|ifthenelsestatement
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|whilestatement
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|forstatement
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
expression :assignmentexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|classinstancecreationexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
integraltype :INT
|
|||
|
{
|
|||
|
IntegerType IT = new IntegerType();
|
|||
|
/* #JB# 05.04.2005 */
|
|||
|
/* ########################################################### */
|
|||
|
//IT.setName($1.getLexem());
|
|||
|
/* ########################################################### */
|
|||
|
$$=IT;
|
|||
|
}
|
|||
|
| CHAR
|
|||
|
{
|
|||
|
CharacterType CT = new CharacterType();
|
|||
|
/* #JB# 05.04.2005 */
|
|||
|
/* ########################################################### */
|
|||
|
//CT.setName($1.getLexem());
|
|||
|
/* ########################################################### */
|
|||
|
$$=CT;
|
|||
|
}
|
|||
|
|
|||
|
localvariabledeclaration : type variabledeclarators
|
|||
|
{
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("P -> Lokale Variable angelegt!");
|
|||
|
LocalVarDecl LVD = new LocalVarDecl($1.getOffset(),$1.getVariableLength());
|
|||
|
LVD.setType($1);
|
|||
|
LVD.setDeclidVector($2.getDeclIdVector());
|
|||
|
$$ = LVD;
|
|||
|
}
|
|||
|
|
|||
|
/* #JB# 31.03.2005 */
|
|||
|
/* ########################################################### */
|
|||
|
|variabledeclarators
|
|||
|
{
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("P -> Lokale Variable angelegt!");
|
|||
|
LocalVarDecl LVD = new LocalVarDecl($1.getOffset(),$1.getVariableLength());
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) LVD.setType(TypePlaceholder.fresh());
|
|||
|
LVD.setDeclidVector($1.getDeclIdVector());
|
|||
|
$$ = LVD;
|
|||
|
}
|
|||
|
/* ########################################################### */
|
|||
|
|
|||
|
statementwithouttrailingsubstatement : block
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| emptystatement
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| expressionstatement
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| returnstatement
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
ifthenstatement : IF '(' expression ')' statement
|
|||
|
{
|
|||
|
IfStmt Ifst = new IfStmt($3.getOffset(),$3.getVariableLength());
|
|||
|
Ifst.set_Expr($3);
|
|||
|
Ifst.set_Then_block($5);
|
|||
|
$$=Ifst;
|
|||
|
}
|
|||
|
|
|||
|
ifthenelsestatement : IF '('expression ')'statementnoshortif ELSE statement
|
|||
|
{
|
|||
|
IfStmt IfstElst = new IfStmt($3.getOffset(),$3.getVariableLength());
|
|||
|
IfstElst.set_Expr($3);
|
|||
|
IfstElst.set_Then_block($5);
|
|||
|
IfstElst.set_Else_block($7);
|
|||
|
$$=IfstElst;
|
|||
|
}
|
|||
|
|
|||
|
whilestatement : WHILE '(' expression ')' statement
|
|||
|
{
|
|||
|
WhileStmt Whlst = new WhileStmt($3.getOffset(),$3.getVariableLength());
|
|||
|
Whlst.set_Expr($3);
|
|||
|
Whlst.set_Loop_block($5);
|
|||
|
$$=Whlst;
|
|||
|
}
|
|||
|
|
|||
|
//forschleife
|
|||
|
forstatement
|
|||
|
//Bsp: for(i=0 ; i<10 ; i++){System.out.println(i)}
|
|||
|
: FOR '(' expression ';' expression ';' expression ')' statement
|
|||
|
{
|
|||
|
ForStmt Fst = new ForStmt($3.getOffset(),$3.getVariableLength());
|
|||
|
Fst.set_head_Initializer($3);
|
|||
|
Fst.set_head_Condition($5);
|
|||
|
Fst.set_head_Loop_expr($7);
|
|||
|
Fst.set_body_Loop_block($9);
|
|||
|
|
|||
|
//Typannahme
|
|||
|
$$ = Fst;
|
|||
|
}
|
|||
|
//Bsp: for(i=0 ; i<10 ; ){System.out.println(i)}
|
|||
|
| FOR '(' expression ';' expression ';' ')' statement
|
|||
|
{
|
|||
|
ForStmt Fst = new ForStmt($3.getOffset(),$3.getVariableLength());
|
|||
|
Fst.set_head_Initializer($3);
|
|||
|
Fst.set_head_Condition($5);
|
|||
|
Fst.set_body_Loop_block($8);
|
|||
|
|
|||
|
//Typannahme
|
|||
|
$$ = Fst;
|
|||
|
}
|
|||
|
//Bsp: for(i=0 ; ; i++){System.out.println(i)}
|
|||
|
| FOR '(' expression ';' ';' expression ')' statement
|
|||
|
{
|
|||
|
ForStmt Fst = new ForStmt($3.getOffset(),$3.getVariableLength());
|
|||
|
Fst.set_head_Initializer($3);
|
|||
|
Fst.set_head_Loop_expr($6);
|
|||
|
Fst.set_body_Loop_block($8);
|
|||
|
|
|||
|
//Typannahme
|
|||
|
$$ = Fst;
|
|||
|
}
|
|||
|
//Bsp: for( ; i<10 ; i++){System.out.println(i)}
|
|||
|
| FOR '(' ';' expression ';' expression ')' statement
|
|||
|
{
|
|||
|
ForStmt Fst = new ForStmt($4.getOffset(),$4.getVariableLength());
|
|||
|
Fst.set_head_Condition($4);
|
|||
|
Fst.set_head_Loop_expr($6);
|
|||
|
Fst.set_body_Loop_block($8);
|
|||
|
|
|||
|
//Typannahme
|
|||
|
$$ = Fst;
|
|||
|
}
|
|||
|
//Bsp: for(i=0 ; ; ){System.out.println(i)}
|
|||
|
| FOR '(' expression ';' ';' ')' statement
|
|||
|
{
|
|||
|
ForStmt Fst = new ForStmt($3.getOffset(),$3.getVariableLength());
|
|||
|
Fst.set_head_Initializer($3);
|
|||
|
Fst.set_body_Loop_block($7);
|
|||
|
|
|||
|
//Typannahme
|
|||
|
$$ = Fst;
|
|||
|
}
|
|||
|
//Bsp: for( ; i<10 ; ){System.out.println(i)}
|
|||
|
| FOR '(' ';' expression ';' ')' statement
|
|||
|
{
|
|||
|
ForStmt Fst = new ForStmt($4.getOffset(),$4.getVariableLength());
|
|||
|
Fst.set_head_Condition($4);
|
|||
|
Fst.set_body_Loop_block($7);
|
|||
|
|
|||
|
//Typannahme
|
|||
|
$$ = Fst;
|
|||
|
}
|
|||
|
//Bsp: for( ; ; i++){System.out.println(i)}
|
|||
|
| FOR '(' ';' ';' expression ')' statement
|
|||
|
{
|
|||
|
ForStmt Fst = new ForStmt($5.getOffset(),$5.getVariableLength());
|
|||
|
Fst.set_head_Loop_expr($5);
|
|||
|
Fst.set_body_Loop_block($7);
|
|||
|
|
|||
|
//Typannahme
|
|||
|
$$ = Fst;
|
|||
|
}
|
|||
|
//Bsp: for( ; ; ){System.out.println(i)}
|
|||
|
| FOR '(' ';' ';' ')' statement
|
|||
|
{
|
|||
|
ForStmt Fst = new ForStmt($6.getOffset(),$6.getVariableLength());
|
|||
|
Fst.set_body_Loop_block($6);
|
|||
|
|
|||
|
//Typannahme
|
|||
|
$$ = Fst;
|
|||
|
}
|
|||
|
|
|||
|
assignmentexpression : conditionalexpression
|
|||
|
{
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("conditionalexpression");
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| assignment
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
emptystatement : ';'
|
|||
|
{
|
|||
|
EmptyStmt Empst = new EmptyStmt();
|
|||
|
$$=Empst;
|
|||
|
}
|
|||
|
|
|||
|
expressionstatement : statementexpression ';'
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
returnstatement : RETURN ';'
|
|||
|
{
|
|||
|
Return ret = new Return(-1,-1);
|
|||
|
$$= ret;
|
|||
|
}
|
|||
|
| RETURN expression ';'
|
|||
|
{
|
|||
|
Return retexp = new Return($2.getOffset(),$2.getVariableLength());
|
|||
|
retexp.set_ReturnExpr($2);
|
|||
|
$$=retexp;
|
|||
|
}
|
|||
|
|
|||
|
statementnoshortif :statementwithouttrailingsubstatement
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| ifthenelsestatementnoshortif
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| whilestatementnoshortif
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
conditionalexpression :conditionalorexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
// | conditionalorexpression '?' expression ':' conditionalexpression
|
|||
|
|
|||
|
assignment :lefthandside assignmentoperator assignmentexpression
|
|||
|
{
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("\nParser --> Zuweisung1!\n");
|
|||
|
Assign Ass = new Assign($1.getOffset(),$1.getVariableLength());
|
|||
|
LocalOrFieldVar LOFV = new LocalOrFieldVar($1.getOffset(),$1.getVariableLength());
|
|||
|
LOFV.set_UsedId($1);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) LOFV.setType(TypePlaceholder.fresh());
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) Ass.setType(TypePlaceholder.fresh());
|
|||
|
if( $2 == null )
|
|||
|
{
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("\nParser --> Zuweisung1 --> " + $3 + " \n");
|
|||
|
Ass.set_Expr( LOFV,$3 );
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
Binary Bin = new Binary($3.getOffset(),$3.getVariableLength());
|
|||
|
Bin.set_Expr1(LOFV);
|
|||
|
Bin.set_Operator($2);
|
|||
|
Bin.set_Expr2($3);
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("\nParser --> Zuweisung1 --> Binary\n");
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) Bin.setType(TypePlaceholder.fresh());
|
|||
|
Ass.set_Expr( LOFV, Bin );
|
|||
|
}
|
|||
|
$$=Ass;
|
|||
|
}
|
|||
|
| lefthandside assignmentoperator classinstancecreationexpression
|
|||
|
{
|
|||
|
Assign Ass =new Assign($1.getOffset(),$1.getVariableLength());
|
|||
|
LocalOrFieldVar LOFV = new LocalOrFieldVar($1.getOffset(),$1.getVariableLength());
|
|||
|
LOFV.set_UsedId($1);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) LOFV.setType(TypePlaceholder.fresh());
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) Ass.setType(TypePlaceholder.fresh());
|
|||
|
if($2==null)
|
|||
|
{
|
|||
|
Ass.set_Expr(LOFV,$3);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
Binary Bin = new Binary($3.getOffset(),$3.getVariableLength());
|
|||
|
Bin.set_Expr1(LOFV);
|
|||
|
Bin.set_Operator($2);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) Bin.setType(TypePlaceholder.fresh());
|
|||
|
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($3.getOffset(),$3.getVariableLength());
|
|||
|
IfElno.set_Expr($3);
|
|||
|
IfElno.set_Then_block($5);
|
|||
|
IfElno.set_Else_block($7);
|
|||
|
$$=IfElno;
|
|||
|
}
|
|||
|
|
|||
|
whilestatementnoshortif :WHILE '(' expression ')' statementnoshortif
|
|||
|
{
|
|||
|
WhileStmt Whstno = new WhileStmt($3.getOffset(),$3.getVariableLength());
|
|||
|
Whstno.set_Expr($3);
|
|||
|
Whstno.set_Loop_block($5);
|
|||
|
$$=Whstno;
|
|||
|
}
|
|||
|
|
|||
|
conditionalorexpression : conditionalandexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| conditionalorexpression LOGICALOR conditionalandexpression
|
|||
|
{
|
|||
|
Binary LogOr = new Binary($1.getOffset(),$1.getVariableLength());
|
|||
|
OrOp OrO = new OrOp($1.getOffset(),$1.getVariableLength());
|
|||
|
LogOr.set_Expr1($1);
|
|||
|
LogOr.set_Expr2($3);
|
|||
|
LogOr.set_Operator(OrO);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) LogOr.setType(TypePlaceholder.fresh());
|
|||
|
$$=LogOr;
|
|||
|
}
|
|||
|
|
|||
|
// LambdaExpression eingef<65>gt von Andreas Stadelmeier, a10023:
|
|||
|
|
|||
|
lambdaassignmentoperator : LAMBDAASSIGNMENT
|
|||
|
{
|
|||
|
$$=null;
|
|||
|
}
|
|||
|
|
|||
|
lambdabody : block
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| expression
|
|||
|
{
|
|||
|
//Lambdabody kann auch nur aus einer Expression bestehen. In diesem Fall wird ein Block erstellt, welcher als einziges Statement ein return statment mit der expression hat.
|
|||
|
//Bsp.: Aus der Expression |var=="hallo"| wird: |{return var=="hallo";}|
|
|||
|
Block ret=new Block();
|
|||
|
ret.statements.add((Statement)new Return(0,0).set_ReturnExpr($1));
|
|||
|
//ret.statements.add((ExprStmt)$1);
|
|||
|
$$=ret;
|
|||
|
}
|
|||
|
|
|||
|
lambdaexpressionparameter : '(' ')'
|
|||
|
{
|
|||
|
$$=null;
|
|||
|
}
|
|||
|
| '(' formalparameterlist ')'
|
|||
|
{
|
|||
|
$$=$2;
|
|||
|
}
|
|||
|
|
|||
|
lambdaexpression : lambdaexpressionparameter lambdaassignmentoperator lambdabody
|
|||
|
{
|
|||
|
LambdaExpression lambda = new LambdaExpression(/*((ParameSterList)$2).getOffset(),((ParameterList)$2).getVariableLength()*/0,0);
|
|||
|
if($1!=null)lambda.setParameterList($1);
|
|||
|
lambda.setBody((Block)$3);
|
|||
|
$$=lambda;
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
| '(' ')' lambdaassignmentoperator lambdabody
|
|||
|
{
|
|||
|
LambdaExpression lambda = new LambdaExpression(0,0); //hier noch fixen
|
|||
|
lambda.setBody((Block)$4);
|
|||
|
$$=lambda;
|
|||
|
}
|
|||
|
*/
|
|||
|
|
|||
|
|
|||
|
|
|||
|
lefthandside :name
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
assignmentoperator : '='
|
|||
|
{
|
|||
|
$$=null;
|
|||
|
}
|
|||
|
| TIMESEQUAL
|
|||
|
{
|
|||
|
TimesOp TEO = new TimesOp(-1,-1);
|
|||
|
$$=TEO;
|
|||
|
}
|
|||
|
| DIVIDEEQUAL
|
|||
|
{
|
|||
|
DivideOp DEO = new DivideOp(-1,-1);
|
|||
|
$$=DEO;
|
|||
|
}
|
|||
|
| MODULOEQUAL
|
|||
|
{
|
|||
|
ModuloOp MEO = new ModuloOp(-1,-1);
|
|||
|
$$=MEO;
|
|||
|
}
|
|||
|
| PLUSEQUAL
|
|||
|
{
|
|||
|
PlusOp PEO = new PlusOp(-1,-1);
|
|||
|
$$=PEO;
|
|||
|
}
|
|||
|
| MINUSEQUAL
|
|||
|
{
|
|||
|
MinusOp MEO = new MinusOp(-1,-1);
|
|||
|
$$=MEO;
|
|||
|
}
|
|||
|
// | SHIFTLEFTEQUAL
|
|||
|
// | SIGNEDSHIFTRIGHTEQUAL
|
|||
|
// | UNSIGNEDSHIFTRIGHTEQUAL
|
|||
|
// | ANDEQUAL
|
|||
|
// | XOREQUAL
|
|||
|
// | OREQUAL
|
|||
|
|
|||
|
preincrementexpression :INCREMENT unaryexpression
|
|||
|
{
|
|||
|
PreIncExpr PRINC = new PreIncExpr($2.getOffset(),$2.getVariableLength());
|
|||
|
PRINC.set_Expr($2);
|
|||
|
$$=PRINC;
|
|||
|
}
|
|||
|
|
|||
|
predecrementexpression :DECREMENT unaryexpression
|
|||
|
{
|
|||
|
PreDecExpr PRDEC = new PreDecExpr($2.getOffset(),$2.getVariableLength());
|
|||
|
PRDEC.set_Expr($2);
|
|||
|
$$=PRDEC;
|
|||
|
}
|
|||
|
|
|||
|
postincrementexpression :postfixexpression INCREMENT
|
|||
|
{
|
|||
|
PostIncExpr PIE = new PostIncExpr($1.getOffset(),$1.getVariableLength());
|
|||
|
PIE.set_Expr($1);
|
|||
|
$$=PIE;
|
|||
|
}
|
|||
|
|
|||
|
postdecrementexpression :postfixexpression DECREMENT
|
|||
|
{
|
|||
|
PostDecExpr PDE = new PostDecExpr($1.getOffset(),$1.getVariableLength());
|
|||
|
PDE.set_Expr($1);
|
|||
|
$$=PDE;
|
|||
|
}
|
|||
|
|
|||
|
methodinvocation:
|
|||
|
name '(' ')'
|
|||
|
{
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("M1");
|
|||
|
MethodCall MC = new MethodCall($1.getOffset(),$1.getVariableLength());
|
|||
|
UsedId udidmeth = new UsedId($1.getOffset());
|
|||
|
udidmeth.set_Name((String)(($1.get_Name()).elementAt($1.get_Name().size()-1)));
|
|||
|
MC.set_UsedId(udidmeth);
|
|||
|
Receiver rec = null;
|
|||
|
if ($1.get_Name().size() > 2) {
|
|||
|
|
|||
|
$1.removeLast();
|
|||
|
|
|||
|
//macht aus der Liste von Strings
|
|||
|
//in usedid.name einen InstVar
|
|||
|
InstVar INSTVA = new InstVar($1,$1.getOffset(),$1.getVariableLength());
|
|||
|
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) INSTVA.setType(TypePlaceholder.fresh());
|
|||
|
rec = new Receiver(INSTVA);
|
|||
|
}
|
|||
|
else if ($1.get_Name().size() == 2) {
|
|||
|
LocalOrFieldVar LOFV = new LocalOrFieldVar($1.getOffset(),$1.getVariableLength());
|
|||
|
$1.removeLast();
|
|||
|
LOFV.set_UsedId($1);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) LOFV.setType(TypePlaceholder.fresh());
|
|||
|
rec = new Receiver(LOFV);
|
|||
|
}
|
|||
|
MC.set_Receiver(rec);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) MC.setType(TypePlaceholder.fresh());
|
|||
|
$$=MC;
|
|||
|
}
|
|||
|
| name '('argumentlist')'
|
|||
|
{
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("M2");
|
|||
|
MethodCall MCarg = new MethodCall($1.getOffset(),$1.getVariableLength());
|
|||
|
UsedId udidmeth = new UsedId($1.getOffset());
|
|||
|
udidmeth.set_Name((String)(($1.get_Name()).elementAt($1.get_Name().size()-1)));
|
|||
|
MCarg.set_UsedId(udidmeth);
|
|||
|
Receiver rec = null;
|
|||
|
if ($1.get_Name().size() > 2) {
|
|||
|
|
|||
|
$1.removeLast();
|
|||
|
|
|||
|
//macht aus der Liste von Strings
|
|||
|
//in usedid.name einen InstVar
|
|||
|
InstVar INSTVA = new InstVar($1,$1.getOffset(),$1.getVariableLength());
|
|||
|
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) INSTVA.setType(TypePlaceholder.fresh());
|
|||
|
rec = new Receiver(INSTVA);
|
|||
|
}
|
|||
|
else if ($1.get_Name().size() == 2) {
|
|||
|
LocalOrFieldVar LOFV = new LocalOrFieldVar($1.getOffset(),$1.getVariableLength());
|
|||
|
$1.removeLast();
|
|||
|
LOFV.set_UsedId($1);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) LOFV.setType(TypePlaceholder.fresh());
|
|||
|
rec = new Receiver(LOFV);
|
|||
|
}
|
|||
|
MCarg.set_Receiver(rec);
|
|||
|
MCarg.set_ArgumentList($3);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) MCarg.setType(TypePlaceholder.fresh());
|
|||
|
$$=MCarg;
|
|||
|
}
|
|||
|
| primary '.' IDENTIFIER '(' ')'
|
|||
|
{
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("M3");
|
|||
|
MethodCall MCpr = new MethodCall($1.getOffset(),$1.getVariableLength());
|
|||
|
|
|||
|
// PL 05-08-21 primary ist kein UsedId
|
|||
|
//$1.usedid.set_Name($3.getLexem());
|
|||
|
//MCpr.set_UsedId($1.get_UsedId());
|
|||
|
UsedId udidmeth = new UsedId($1.getOffset());
|
|||
|
udidmeth.set_Name($3.getLexem());
|
|||
|
MCpr.set_UsedId(udidmeth);
|
|||
|
|
|||
|
/* #JB# 04.06.2005 */
|
|||
|
/* ########################################################### */
|
|||
|
MCpr.set_Receiver(new Receiver($1));
|
|||
|
/* ########################################################### */
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) MCpr.setType(TypePlaceholder.fresh());
|
|||
|
$$=MCpr;
|
|||
|
}
|
|||
|
| primary '.' IDENTIFIER '('argumentlist ')'
|
|||
|
{
|
|||
|
org.apache.log4j.Logger.getLogger("parser").debug("M4");
|
|||
|
MethodCall MCPA = new MethodCall($1.getOffset(),$1.getVariableLength());
|
|||
|
|
|||
|
// PL 05-08-21 primary ist kein UsedId
|
|||
|
//$1.usedid.set_Name($3.getLexem());
|
|||
|
//MCPA.set_UsedId($1.get_UsedId());
|
|||
|
UsedId udidmeth = new UsedId($3.getOffset());
|
|||
|
udidmeth.set_Name($3.getLexem());
|
|||
|
MCPA.set_UsedId(udidmeth);
|
|||
|
|
|||
|
/* #JB# 04.06.2005 */
|
|||
|
/* ########################################################### */
|
|||
|
MCPA.set_Receiver(new Receiver($1));
|
|||
|
/* ########################################################### */
|
|||
|
MCPA.set_ArgumentList($5);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) MCPA.setType(TypePlaceholder.fresh());
|
|||
|
$$=MCPA;
|
|||
|
}
|
|||
|
// | SUPER '.' IDENTIFIER '(' ')'
|
|||
|
// | SUPER '.' IDENTIFIER '('argumentlist')'
|
|||
|
|
|||
|
classinstancecreationexpression : NEW classtype '(' ')'
|
|||
|
{
|
|||
|
NewClass NC = new NewClass($2.getOffset(),$2.getVariableLength());
|
|||
|
NC.set_UsedId($2);
|
|||
|
usedIdsToCheck.addElement($2);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) NC.setType(TypePlaceholder.fresh());
|
|||
|
$$=NC;
|
|||
|
}
|
|||
|
| NEW classtype '(' argumentlist ')'
|
|||
|
{
|
|||
|
NewClass NCarg = new NewClass($2.getOffset(),$2.getVariableLength());
|
|||
|
NCarg.set_UsedId($2);
|
|||
|
usedIdsToCheck.addElement($2);
|
|||
|
NCarg.set_ArgumentList($4);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) NCarg.setType(TypePlaceholder.fresh());
|
|||
|
$$=NCarg;
|
|||
|
}
|
|||
|
|
|||
|
conditionalandexpression : inclusiveorexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| conditionalandexpression LOGICALAND inclusiveorexpression
|
|||
|
{
|
|||
|
Binary And = new Binary($1.getOffset(),$1.getVariableLength());
|
|||
|
AndOp AndO = new AndOp($1.getOffset(),$1.getVariableLength());
|
|||
|
And.set_Expr1($1);
|
|||
|
And.set_Expr2($3);
|
|||
|
And.set_Operator(AndO);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) And.setType(TypePlaceholder.fresh());
|
|||
|
$$=And;
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
fieldaccess :primary '.' IDENTIFIER
|
|||
|
| SUPER '.' IDENTIFIER
|
|||
|
*/
|
|||
|
|
|||
|
unaryexpression : preincrementexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| predecrementexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| '+' unaryexpression
|
|||
|
{
|
|||
|
PositivExpr POSEX=new PositivExpr($2.getOffset(),$2.getVariableLength());
|
|||
|
UnaryPlus UP= new UnaryPlus();
|
|||
|
POSEX.set_UnaryPlus(UP);
|
|||
|
POSEX.set_Expr($2);
|
|||
|
$$=POSEX;
|
|||
|
}
|
|||
|
| '-' unaryexpression
|
|||
|
{
|
|||
|
NegativeExpr NEGEX=new NegativeExpr($2.getOffset(),$2.getVariableLength());
|
|||
|
UnaryMinus UM=new UnaryMinus();
|
|||
|
NEGEX.set_UnaryMinus(UM);
|
|||
|
NEGEX.set_Expr($2);
|
|||
|
$$=NEGEX;
|
|||
|
}
|
|||
|
| unaryexpressionnotplusminus
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
postfixexpression :primary
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| name
|
|||
|
{
|
|||
|
if ($1.get_Name().size() > 1) {
|
|||
|
|
|||
|
//macht aus der Liste von Strings
|
|||
|
//in usedid.name einen InstVar
|
|||
|
InstVar INSTVA = new InstVar($1,$1.getOffset(),$1.getVariableLength());
|
|||
|
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) INSTVA.setType(TypePlaceholder.fresh());
|
|||
|
$$ = INSTVA;
|
|||
|
}
|
|||
|
else {
|
|||
|
LocalOrFieldVar Postincexpr = new LocalOrFieldVar($1.getOffset(),$1.getVariableLength());
|
|||
|
Postincexpr.set_UsedId($1);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) Postincexpr.setType(TypePlaceholder.fresh());
|
|||
|
$$=Postincexpr;
|
|||
|
}
|
|||
|
}
|
|||
|
| postincrementexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| postdecrementexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
primary : primarynonewarray
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
inclusiveorexpression : exclusiveorexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| inclusiveorexpression '|' exclusiveorexpression
|
|||
|
|
|||
|
primarynonewarray : literal
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| THIS
|
|||
|
{
|
|||
|
This T = new This($1.getOffset(),$1.getLexem().length());
|
|||
|
UsedId UT = new UsedId($1.getOffset());
|
|||
|
UT.set_Name($1.getLexem());
|
|||
|
T.set_UsedId(UT);
|
|||
|
$$=T;
|
|||
|
}
|
|||
|
/* auskommentiert von Andreas Stadelmeier
|
|||
|
| '('expression')'
|
|||
|
{
|
|||
|
$$=$2;
|
|||
|
}
|
|||
|
*/
|
|||
|
/*
|
|||
|
| classinstancecreationexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| fieldaccess
|
|||
|
*/
|
|||
|
| methodinvocation
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|lambdaexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
unaryexpressionnotplusminus : postfixexpression {$$=$1;}
|
|||
|
// | '~' unaryexpression
|
|||
|
| '!' unaryexpression {NotExpr NE=new NotExpr($2.getOffset(),$2.getVariableLength());
|
|||
|
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;
|
|||
|
}
|
|||
|
| LONGLITERAL { LongLiteral LL = new LongLiteral();
|
|||
|
LL.set_Long($1.String2Long());
|
|||
|
$$ = LL;
|
|||
|
}
|
|||
|
| FLOATLITERAL {
|
|||
|
FloatLiteral FL = new FloatLiteral();
|
|||
|
FL.set_Float($1.String2Float());
|
|||
|
$$ = FL;
|
|||
|
}
|
|||
|
| DOUBLELITERAL {
|
|||
|
DoubleLiteral DL = new DoubleLiteral();
|
|||
|
DL.set_Double($1.String2Double());
|
|||
|
$$ = DL;
|
|||
|
}
|
|||
|
| JNULL;
|
|||
|
{
|
|||
|
Null NN = new Null();
|
|||
|
$$=NN;
|
|||
|
}
|
|||
|
|
|||
|
castexpression : '(' primitivetype ')' unaryexpression
|
|||
|
{
|
|||
|
CastExpr CaEx=new CastExpr($4.getOffset(),$4.getVariableLength());
|
|||
|
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($1.getOffset(),$1.getVariableLength());
|
|||
|
EqualOp EO = new EqualOp($1.getOffset(),$1.getVariableLength());
|
|||
|
EQ.set_Expr1($1);
|
|||
|
EQ.set_Expr2($3);
|
|||
|
EQ.set_Operator(EO);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) EQ.setType(TypePlaceholder.fresh());
|
|||
|
$$=EQ;
|
|||
|
}
|
|||
|
| equalityexpression NOTEQUAL relationalexpression
|
|||
|
{
|
|||
|
Binary NEQ = new Binary($1.getOffset(),$1.getVariableLength());
|
|||
|
NotEqualOp NEO = new NotEqualOp($1.getOffset(),$1.getVariableLength());
|
|||
|
NEQ.set_Expr1($1);
|
|||
|
NEQ.set_Expr2($3);
|
|||
|
NEQ.set_Operator(NEO);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) NEQ.setType(TypePlaceholder.fresh());
|
|||
|
$$=NEQ;
|
|||
|
}
|
|||
|
|
|||
|
relationalexpression : shiftexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| relationalexpression '<' shiftexpression
|
|||
|
{
|
|||
|
Binary LO = new Binary($1.getOffset(),$1.getVariableLength());
|
|||
|
LessOp LOO = new LessOp($1.getOffset(),$1.getVariableLength());
|
|||
|
LO.set_Expr1($1);
|
|||
|
LO.set_Expr2($3);
|
|||
|
LO.set_Operator(LOO);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) LO.setType(TypePlaceholder.fresh());
|
|||
|
$$=LO;
|
|||
|
}
|
|||
|
| relationalexpression '>' shiftexpression
|
|||
|
{
|
|||
|
Binary GO = new Binary($1.getOffset(),$1.getVariableLength());
|
|||
|
GreaterOp GOO = new GreaterOp($1.getOffset(),$1.getVariableLength());
|
|||
|
GO.set_Expr1($1);
|
|||
|
GO.set_Expr2($3);
|
|||
|
GO.set_Operator( GOO );
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) GO.setType(TypePlaceholder.fresh());
|
|||
|
$$=GO;
|
|||
|
}
|
|||
|
| relationalexpression LESSEQUAL shiftexpression
|
|||
|
{
|
|||
|
Binary LE = new Binary($1.getOffset(),$1.getVariableLength());
|
|||
|
LessEquOp LEO = new LessEquOp($1.getOffset(),$1.getVariableLength());
|
|||
|
LE.set_Expr1($1);
|
|||
|
LE.set_Expr2($3);
|
|||
|
LE.set_Operator(LEO);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) LE.setType(TypePlaceholder.fresh());
|
|||
|
$$=LE;
|
|||
|
}
|
|||
|
| relationalexpression GREATEREQUAL shiftexpression
|
|||
|
{
|
|||
|
Binary GE = new Binary($1.getOffset(),$1.getVariableLength());
|
|||
|
GreaterEquOp GEO = new GreaterEquOp($1.getOffset(),$1.getVariableLength());
|
|||
|
GE.set_Expr1($1);
|
|||
|
GE.set_Expr2($3);
|
|||
|
GE.set_Operator(GEO);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) GE.setType(TypePlaceholder.fresh());
|
|||
|
$$=GE;
|
|||
|
}
|
|||
|
| relationalexpression INSTANCEOF referencetype
|
|||
|
{
|
|||
|
InstanceOf ISO=new InstanceOf($1.getOffset(),$1.getVariableLength());
|
|||
|
ISO.set_Expr($1);
|
|||
|
ISO.set_Type($3);
|
|||
|
$$=ISO;
|
|||
|
}
|
|||
|
|
|||
|
shiftexpression : additiveexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
|
|||
|
additiveexpression :multiplicativeexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| additiveexpression '+' multiplicativeexpression
|
|||
|
{
|
|||
|
Binary AD = new Binary($1.getOffset(),$1.getVariableLength());
|
|||
|
PlusOp PO = new PlusOp($1.getOffset(),$1.getVariableLength());
|
|||
|
AD.set_Expr1($1);
|
|||
|
AD.set_Expr2($3);
|
|||
|
AD.set_Operator(PO);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) AD.setType(TypePlaceholder.fresh());
|
|||
|
$$=AD;
|
|||
|
}
|
|||
|
| additiveexpression '-' multiplicativeexpression
|
|||
|
{
|
|||
|
Binary MI = new Binary($1.getOffset(),$1.getVariableLength());
|
|||
|
MinusOp MO = new MinusOp($1.getOffset(),$1.getVariableLength());
|
|||
|
MI.set_Expr1($1);
|
|||
|
MI.set_Expr2($3);
|
|||
|
MI.set_Operator(MO);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) MI.setType(TypePlaceholder.fresh());
|
|||
|
$$=MI;
|
|||
|
}
|
|||
|
|
|||
|
multiplicativeexpression : unaryexpression
|
|||
|
{
|
|||
|
$$=$1;
|
|||
|
}
|
|||
|
| multiplicativeexpression '*' unaryexpression
|
|||
|
{
|
|||
|
Binary ML = new Binary($1.getOffset(),$1.getVariableLength());
|
|||
|
TimesOp TO = new TimesOp($1.getOffset(),$1.getVariableLength());
|
|||
|
ML.set_Expr1($1);
|
|||
|
ML.set_Expr2($3);
|
|||
|
ML.set_Operator(TO);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) ML.setType(TypePlaceholder.fresh());
|
|||
|
$$=ML;
|
|||
|
}
|
|||
|
| multiplicativeexpression '/' unaryexpression
|
|||
|
{
|
|||
|
Binary DV = new Binary($1.getOffset(),$1.getVariableLength());
|
|||
|
DivideOp DO = new DivideOp($1.getOffset(),$1.getVariableLength());
|
|||
|
DV.set_Expr1($1);
|
|||
|
DV.set_Expr2($3);
|
|||
|
DV.set_Operator(DO);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) DV.setType(TypePlaceholder.fresh());
|
|||
|
$$ = DV;
|
|||
|
}
|
|||
|
| multiplicativeexpression '%' unaryexpression
|
|||
|
{
|
|||
|
Binary MD = new Binary($1.getOffset(),$1.getVariableLength());
|
|||
|
ModuloOp MO = new ModuloOp($1.getOffset(),$1.getVariableLength());
|
|||
|
MD.set_Expr1($1);
|
|||
|
MD.set_Expr2($3);
|
|||
|
MD.set_Operator(MO);
|
|||
|
//auskommentiert von Andreas Stadelmeier (a10023) MD.setType(TypePlaceholder.fresh());
|
|||
|
$$ =MD;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
%%
|