/*
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.test.lib.jittester.factories;
import java.util.Collection;
import java.util.Optional;
import jdk.test.lib.jittester.BinaryOperator;
import jdk.test.lib.jittester.Block;
import jdk.test.lib.jittester.Break;
import jdk.test.lib.jittester.CastOperator;
import jdk.test.lib.jittester.Continue;
import jdk.test.lib.jittester.Declaration;
import jdk.test.lib.jittester.IRNode;
import jdk.test.lib.jittester.If;
import jdk.test.lib.jittester.Literal;
import jdk.test.lib.jittester.LocalVariable;
import jdk.test.lib.jittester.NonStaticMemberVariable;
import jdk.test.lib.jittester.Nothing;
import jdk.test.lib.jittester.Operator;
import jdk.test.lib.jittester.OperatorKind;
import jdk.test.lib.jittester.PrintVariables;
import jdk.test.lib.jittester.ProductionFailedException;
import jdk.test.lib.jittester.ProductionParams;
import jdk.test.lib.jittester.Statement;
import jdk.test.lib.jittester.StaticMemberVariable;
import jdk.test.lib.jittester.Switch;
import jdk.test.lib.jittester.Symbol;
import jdk.test.lib.jittester.TernaryOperator;
import jdk.test.lib.jittester.Throw;
import jdk.test.lib.jittester.TryCatchBlock;
import jdk.test.lib.jittester.Type;
import jdk.test.lib.jittester.TypeList;
import jdk.test.lib.jittester.UnaryOperator;
import jdk.test.lib.jittester.VariableBase;
import jdk.test.lib.jittester.VariableDeclaration;
import jdk.test.lib.jittester.VariableDeclarationBlock;
import jdk.test.lib.jittester.VariableInitialization;
import jdk.test.lib.jittester.arrays.ArrayCreation;
import jdk.test.lib.jittester.arrays.ArrayElement;
import jdk.test.lib.jittester.arrays.ArrayExtraction;
import jdk.test.lib.jittester.classes.ClassDefinitionBlock;
import jdk.test.lib.jittester.classes.Interface;
import jdk.test.lib.jittester.classes.Klass;
import jdk.test.lib.jittester.classes.MainKlass;
import jdk.test.lib.jittester.functions.ArgumentDeclaration;
import jdk.test.lib.jittester.functions.ConstructorDefinition;
import jdk.test.lib.jittester.functions.ConstructorDefinitionBlock;
import jdk.test.lib.jittester.functions.Function;
import jdk.test.lib.jittester.functions.FunctionDeclaration;
import jdk.test.lib.jittester.functions.FunctionDeclarationBlock;
import jdk.test.lib.jittester.functions.FunctionDefinition;
import jdk.test.lib.jittester.functions.FunctionDefinitionBlock;
import jdk.test.lib.jittester.functions.FunctionInfo;
import jdk.test.lib.jittester.functions.FunctionRedefinition;
import jdk.test.lib.jittester.functions.FunctionRedefinitionBlock;
import jdk.test.lib.jittester.functions.Return;
import jdk.test.lib.jittester.functions.StaticConstructorDefinition;
import jdk.test.lib.jittester.loops.CounterInitializer;
import jdk.test.lib.jittester.loops.CounterManipulator;
import jdk.test.lib.jittester.loops.DoWhile;
import jdk.test.lib.jittester.loops.For;
import jdk.test.lib.jittester.loops.LoopingCondition;
import jdk.test.lib.jittester.loops.While;
import jdk.test.lib.jittester.types.TypeKlass;
public class IRNodeBuilder {
//private Optional<Type> variableType = Optional.empty();
private Optional<TypeKlass> argumentType = Optional.empty();
private Optional<Integer> variableNumber = Optional.empty();
private Optional<Long> complexityLimit = Optional.empty();
private Optional<Integer> operatorLimit = Optional.empty();
private Optional<TypeKlass> ownerClass = Optional.empty();
private Optional<Type> resultType = Optional.empty();
private Optional<Boolean> safe = Optional.empty();
private Optional<Boolean> noConsts = Optional.empty();
private Optional<OperatorKind> opKind = Optional.empty();
private Optional<Integer> statementLimit = Optional.empty();
private Optional<Boolean> subBlock = Optional.empty();
private Optional<Boolean> canHaveBreaks = Optional.empty();
private Optional<Boolean> canHaveContinues = Optional.empty();
private Optional<Boolean> canHaveReturn = Optional.empty();
//not in use yet because 'throw' is only placed to the locations where 'return' is allowed
private Optional<Boolean> canHaveThrow = Optional.empty();
private Optional<Integer> level = Optional.empty();
private Optional<String> prefix = Optional.empty();
private Optional<Integer> memberFunctionsLimit = Optional.empty();
private Optional<Integer> memberFunctionsArgLimit = Optional.empty();
private Optional<LocalVariable> localVariable = Optional.empty();
private Optional<Boolean> isLocal = Optional.empty();
private Optional<Boolean> isStatic = Optional.empty();
private Optional<Boolean> isConstant = Optional.empty();
private Optional<Boolean> isInitialized = Optional.empty();
private Optional<String> name = Optional.empty();
private Optional<Integer> flags = Optional.empty();
private Optional<FunctionInfo> functionInfo = Optional.empty();
private Optional<Boolean> semicolon = Optional.empty();
public Factory<ArgumentDeclaration> getArgumentDeclarationFactory() {
return new ArgumentDeclarationFactory(getArgumentType(), getVariableNumber());
}
public Factory<Operator> getArithmeticOperatorFactory() throws ProductionFailedException {
return new ArithmeticOperatorFactory(getComplexityLimit(), getOperatorLimit(),
getOwnerClass(), getResultType(), getExceptionSafe(), getNoConsts());
}
public Factory<ArrayCreation> getArrayCreationFactory() {
return new ArrayCreationFactory(getComplexityLimit(), getOperatorLimit(), getOwnerClass(),
getResultType(), getExceptionSafe(), getNoConsts());
}
public Factory<ArrayElement> getArrayElementFactory() {
return new ArrayElementFactory(getComplexityLimit(), getOperatorLimit(), getOwnerClass(),
getResultType(), getExceptionSafe(), getNoConsts());
}
public Factory<ArrayExtraction> getArrayExtractionFactory() {
return new ArrayExtractionFactory(getComplexityLimit(), getOperatorLimit(), getOwnerClass(),
getResultType(), getExceptionSafe(), getNoConsts());
}
public Factory<Operator> getAssignmentOperatorFactory() {
return new AssignmentOperatorFactory(getComplexityLimit(), getOperatorLimit(),
getOwnerClass(), resultType.orElse(null), getExceptionSafe(), getNoConsts());
}
public Factory<BinaryOperator> getBinaryOperatorFactory() throws ProductionFailedException {
OperatorKind o = getOperatorKind();
switch (o) {
case ASSIGN:
return new AssignmentOperatorImplFactory(getComplexityLimit(), getOperatorLimit(),
getOwnerClass(), resultType.orElse(null), getExceptionSafe(), getNoConsts());
case AND:
case OR:
return new BinaryLogicOperatorFactory(o, getComplexityLimit(), getOperatorLimit(),
getOwnerClass(), resultType.orElse(null), getExceptionSafe(), getNoConsts());
case BIT_OR:
case BIT_XOR:
case BIT_AND:
return new BinaryBitwiseOperatorFactory(o, getComplexityLimit(), getOperatorLimit(),
getOwnerClass(), resultType.orElse(null), getExceptionSafe(), getNoConsts());
case EQ:
case NE:
return new BinaryEqualityOperatorFactory(o, getComplexityLimit(),
getOperatorLimit(), getOwnerClass(), resultType.orElse(null), getExceptionSafe(),
getNoConsts());
case GT:
case LT:
case GE:
case LE:
return new BinaryComparisonOperatorFactory(o, getComplexityLimit(),
getOperatorLimit(), getOwnerClass(), resultType.orElse(null), getExceptionSafe(),
getNoConsts());
case SHR:
case SHL:
case SAR:
return new BinaryShiftOperatorFactory(o, getComplexityLimit(), getOperatorLimit(),
getOwnerClass(), resultType.orElse(null), getExceptionSafe(), getNoConsts());
case ADD:
case SUB:
case MUL:
case DIV:
case MOD:
return new BinaryArithmeticOperatorFactory(o, getComplexityLimit(),
getOperatorLimit(), getOwnerClass(), resultType.orElse(null), getExceptionSafe(),
getNoConsts());
case STRADD:
return new BinaryStringPlusFactory(getComplexityLimit(), getOperatorLimit(),
getOwnerClass(), resultType.orElse(null), getExceptionSafe(), getNoConsts());
case COMPOUND_ADD:
case COMPOUND_SUB:
case COMPOUND_MUL:
case COMPOUND_DIV:
case COMPOUND_MOD:
return new CompoundArithmeticAssignmentOperatorFactory(o, getComplexityLimit(),
getOperatorLimit(), getOwnerClass(), resultType.orElse(null), getExceptionSafe(),
getNoConsts());
case COMPOUND_AND:
case COMPOUND_OR:
case COMPOUND_XOR:
return new CompoundBitwiseAssignmentOperatorFactory(o, getComplexityLimit(),
getOperatorLimit(), getOwnerClass(), resultType.orElse(null), getExceptionSafe(),
getNoConsts());
case COMPOUND_SHR:
case COMPOUND_SHL:
case COMPOUND_SAR:
return new CompoundShiftAssignmentOperatorFactory(o, getComplexityLimit(),
getOperatorLimit(), getOwnerClass(), resultType.orElse(null), getExceptionSafe(),
getNoConsts());
default:
throw new ProductionFailedException();
}
}
public Factory<UnaryOperator> getUnaryOperatorFactory() throws ProductionFailedException {
OperatorKind o = getOperatorKind();
switch (o) {
case NOT:
return new LogicalInversionOperatorFactory(getComplexityLimit(),
getOperatorLimit(), getOwnerClass(), resultType.orElse(null), getExceptionSafe(),
getNoConsts());
case BIT_NOT:
return new BitwiseInversionOperatorFactory(getComplexityLimit(),
getOperatorLimit(), getOwnerClass(), resultType.orElse(null), getExceptionSafe(),
getNoConsts());
case UNARY_PLUS:
case UNARY_MINUS:
return new UnaryPlusMinusOperatorFactory(o, getComplexityLimit(),
getOperatorLimit(), getOwnerClass(), resultType.orElse(null), getExceptionSafe(),
getNoConsts());
case PRE_DEC:
case POST_DEC:
case PRE_INC:
case POST_INC:
return new IncDecOperatorFactory(o, getComplexityLimit(), getOperatorLimit(),
getOwnerClass(), resultType.orElse(null), getExceptionSafe(), getNoConsts());
default:
throw new ProductionFailedException();
}
}
public Factory<Block> getBlockFactory() {
return new BlockFactory(getOwnerClass(), getResultType(), getComplexityLimit(),
getStatementLimit(), getOperatorLimit(), getLevel(), subBlock.orElse(false),
canHaveBreaks.orElse(false), canHaveContinues.orElse(false),
canHaveReturn.orElse(false), canHaveReturn.orElse(false));
//now 'throw' can be placed only in the same positions as 'return'
}
public Factory<Break> getBreakFactory() {
return new BreakFactory();
}
public Factory<CastOperator> getCastOperatorFactory() {
return new CastOperatorFactory(getComplexityLimit(), getOperatorLimit(), getOwnerClass(),
getResultType(), getExceptionSafe(), getNoConsts());
}
public Factory<ClassDefinitionBlock> getClassDefinitionBlockFactory() {
return new ClassDefinitionBlockFactory(getPrefix(),
ProductionParams.classesLimit.value(),
ProductionParams.memberFunctionsLimit.value(),
ProductionParams.memberFunctionsArgLimit.value(),
getComplexityLimit(),
ProductionParams.statementLimit.value(),
ProductionParams.operatorLimit.value(),
getLevel());
}
public Factory<MainKlass> getMainKlassFactory() {
return new MainKlassFactory(getName(), getComplexityLimit(),
ProductionParams.memberFunctionsLimit.value(),
ProductionParams.memberFunctionsArgLimit.value(),
ProductionParams.statementLimit.value(),
ProductionParams.testStatementLimit.value(),
ProductionParams.operatorLimit.value());
}
public Factory<ConstructorDefinitionBlock> getConstructorDefinitionBlockFactory() {
return new ConstructorDefinitionBlockFactory(getOwnerClass(), getMemberFunctionsLimit(),
ProductionParams.memberFunctionsArgLimit.value(), getComplexityLimit(),
getStatementLimit(), getOperatorLimit(), getLevel());
}
public Factory<ConstructorDefinition> getConstructorDefinitionFactory() {
return new ConstructorDefinitionFactory(getOwnerClass(), getComplexityLimit(),
getStatementLimit(), getOperatorLimit(),
getMemberFunctionsArgLimit(), getLevel());
}
public Factory<Continue> getContinueFactory() {
return new ContinueFactory();
}
public Factory<CounterInitializer> getCounterInitializerFactory(int counterValue) {
return new CounterInitializerFactory(getOwnerClass(), counterValue);
}
public Factory<CounterManipulator> getCounterManipulatorFactory() {
return new CounterManipulatorFactory(getLocalVariable());
}
public Factory<Declaration> getDeclarationFactory() {
return new DeclarationFactory(getOwnerClass(), getComplexityLimit(), getOperatorLimit(),
getIsLocal(), getExceptionSafe());
}
public Factory<DoWhile> getDoWhileFactory() {
return new DoWhileFactory(getOwnerClass(), getResultType(), getComplexityLimit(),
getStatementLimit(), getOperatorLimit(), getLevel(), getCanHaveReturn());
}
public Factory<While> getWhileFactory() {
return new WhileFactory(getOwnerClass(), getResultType(), getComplexityLimit(),
getStatementLimit(), getOperatorLimit(), getLevel(), getCanHaveReturn());
}
public Factory<If> getIfFactory() {
return new IfFactory(getOwnerClass(), getResultType(), getComplexityLimit(),
getStatementLimit(), getOperatorLimit(), getLevel(), getCanHaveBreaks(),
getCanHaveContinues(), getCanHaveReturn());
}
public Factory<For> getForFactory() {
return new ForFactory(getOwnerClass(), getResultType(), getComplexityLimit(),
getStatementLimit(), getOperatorLimit(), getLevel(), getCanHaveReturn());
}
public Factory<Switch> getSwitchFactory() { // TODO: switch is not used now
return new SwitchFactory(getOwnerClass(), getComplexityLimit(), getStatementLimit(),
getOperatorLimit(), getLevel(), getCanHaveReturn());
}
public Factory<IRNode> getExpressionFactory() throws ProductionFailedException {
return new ExpressionFactory(getComplexityLimit(), getOperatorLimit(), getOwnerClass(),
getResultType(), getExceptionSafe(), getNoConsts());
}
public Factory<FunctionDeclarationBlock> getFunctionDeclarationBlockFactory() {
return new FunctionDeclarationBlockFactory(getOwnerClass(), getMemberFunctionsLimit(),
getMemberFunctionsArgLimit(), getLevel());
}
public Factory<FunctionDeclaration> getFunctionDeclarationFactory() {
return new FunctionDeclarationFactory(getName(), getOwnerClass(),resultType.orElse(TypeList.VOID),
getMemberFunctionsArgLimit(), getFlags());
}
public Factory<FunctionDefinitionBlock> getFunctionDefinitionBlockFactory() {
return new FunctionDefinitionBlockFactory(getOwnerClass(), getMemberFunctionsLimit(),
getMemberFunctionsArgLimit(), getComplexityLimit(), getStatementLimit(),
getOperatorLimit(), getLevel(), getFlags());
}
public Factory<FunctionDefinition> getFunctionDefinitionFactory() {
return new FunctionDefinitionFactory(getName(), getOwnerClass(), resultType.orElse(TypeList.VOID),
getComplexityLimit(), getStatementLimit(), getOperatorLimit(),
getMemberFunctionsArgLimit(), getLevel(), getFlags());
}
public Factory<Function> getFunctionFactory() {
return new FunctionFactory(getComplexityLimit(), getOperatorLimit(), getOwnerClass(),
resultType.orElse(null), getExceptionSafe());
}
public Factory<FunctionRedefinitionBlock> getFunctionRedefinitionBlockFactory(Collection<Symbol>
functionSet) {
return new FunctionRedefinitionBlockFactory(functionSet, getOwnerClass(),
getComplexityLimit(), getStatementLimit(), getOperatorLimit(), getLevel());
}
public Factory<FunctionRedefinition> getFunctionRedefinitionFactory() {
return new FunctionRedefinitionFactory(getFunctionInfo(), getOwnerClass(),
getComplexityLimit(), getStatementLimit(), getOperatorLimit(), getLevel(),
getFlags());
}
public Factory<Interface> getInterfaceFactory() {
return new InterfaceFactory(getName(), getMemberFunctionsLimit(),
getMemberFunctionsArgLimit(), getLevel());
}
public Factory<Klass> getKlassFactory() {
return new KlassFactory(getName(), getComplexityLimit(),
getMemberFunctionsLimit(), getMemberFunctionsArgLimit(), getStatementLimit(),
getOperatorLimit(), getLevel());
}
public Factory<IRNode> getLimitedExpressionFactory() throws ProductionFailedException {
return new LimitedExpressionFactory(getComplexityLimit(), getOperatorLimit(),
getOwnerClass(), getResultType(), getExceptionSafe(), getNoConsts());
}
public Factory<Literal> getLiteralFactory() {
return new LiteralFactory(getResultType());
}
public Factory<LocalVariable> getLocalVariableFactory() {
return new LocalVariableFactory(/*getVariableType()*/getResultType(), getFlags());
}
public Factory<Operator> getLogicOperatorFactory() throws ProductionFailedException {
return new LogicOperatorFactory(getComplexityLimit(), getOperatorLimit(), getOwnerClass(),
getResultType(), getExceptionSafe(), getNoConsts());
}
public Factory<LoopingCondition> getLoopingConditionFactory(Literal _limiter) {
return new LoopingConditionFactory(getComplexityLimit(), getOperatorLimit(), getOwnerClass(),
getLocalVariable(), _limiter);
}
public Factory<NonStaticMemberVariable> getNonStaticMemberVariableFactory() {
return new NonStaticMemberVariableFactory(getComplexityLimit(), getOperatorLimit(),
getOwnerClass(), /*getVariableType()*/getResultType(), getFlags(), getExceptionSafe());
}
public Factory<Nothing> getNothingFactory() {
return new NothingFactory();
}
public Factory<PrintVariables> getPrintVariablesFactory() {
return new PrintVariablesFactory(getOwnerClass(), getLevel());
}
public Factory<Return> getReturnFactory() {
return new ReturnFactory(getComplexityLimit(), getOperatorLimit(), getOwnerClass(),
getResultType(), getExceptionSafe());
}
public Factory<Throw> getThrowFactory() {
return new ThrowFactory(getComplexityLimit(), getOperatorLimit(), getOwnerClass(), getResultType(), getExceptionSafe());
}
public Factory<Statement> getStatementFactory() {
return new StatementFactory(getComplexityLimit(), getOperatorLimit(), getOwnerClass(),
getExceptionSafe(), getNoConsts(), semicolon.orElse(true));
}
public Factory<StaticConstructorDefinition> getStaticConstructorDefinitionFactory() {
return new StaticConstructorDefinitionFactory(getOwnerClass(), getComplexityLimit(),
getStatementLimit(), getOperatorLimit(), getLevel());
}
public Factory<StaticMemberVariable> getStaticMemberVariableFactory() {
return new StaticMemberVariableFactory(getOwnerClass(), /*getVariableType()*/getResultType(), getFlags());
}
public Factory<TernaryOperator> getTernaryOperatorFactory() {
return new TernaryOperatorFactory(getComplexityLimit(), getOperatorLimit(), getOwnerClass(),
getResultType(), getExceptionSafe(), getNoConsts());
}
public Factory<VariableDeclarationBlock> getVariableDeclarationBlockFactory() {
return new VariableDeclarationBlockFactory(getOwnerClass(), getComplexityLimit(),
getOperatorLimit(), getLevel(), getExceptionSafe());
}
public Factory<VariableDeclaration> getVariableDeclarationFactory() {
return new VariableDeclarationFactory(getOwnerClass(), getIsStatic(), getIsLocal(), getResultType());
}
public Factory<VariableBase> getVariableFactory() {
return new VariableFactory(getComplexityLimit(), getOperatorLimit(), getOwnerClass(),
/*getVariableType()*/getResultType(), getIsConstant(), getIsInitialized(), getExceptionSafe(), getNoConsts());
}
public Factory<VariableInitialization> getVariableInitializationFactory() {
return new VariableInitializationFactory(getOwnerClass(), getIsConstant(), getIsStatic(),
getIsLocal(), getComplexityLimit(), getOperatorLimit(), getExceptionSafe());
}
public Factory<TryCatchBlock> getTryCatchBlockFactory() {
return new TryCatchBlockFactory(getOwnerClass(), getResultType(),
getComplexityLimit(), getStatementLimit(), getOperatorLimit(),
getLevel(), subBlock.orElse(false), getCanHaveBreaks(),
getCanHaveContinues(), getCanHaveReturn());
}
/* public IRNodeBuilder setVariableType(Type value) {
variableType = Optional.of(value);
return this;
}*/
public IRNodeBuilder setArgumentType(TypeKlass value) {
argumentType = Optional.of(value);
return this;
}
public IRNodeBuilder setVariableNumber(int value) {
variableNumber = Optional.of(value);
return this;
}
public IRNodeBuilder setComplexityLimit(long value) {
complexityLimit = Optional.of(value);
return this;
}
public IRNodeBuilder setOperatorLimit(int value) {
operatorLimit = Optional.of(value);
return this;
}
public IRNodeBuilder setStatementLimit(int value) {
statementLimit = Optional.of(value);
return this;
}
public IRNodeBuilder setOwnerKlass(TypeKlass value) {
ownerClass = Optional.of(value);
return this;
}
public IRNodeBuilder setResultType(Type value) {
resultType = Optional.of(value);
return this;
}
// TODO: check if safe is always true in current implementation
public IRNodeBuilder setExceptionSafe(boolean value) {
safe = Optional.of(value);
return this;
}
// TODO: check is noconsts is always false in current implementation
public IRNodeBuilder setNoConsts(boolean value) {
noConsts = Optional.of(value);
return this;
}
public IRNodeBuilder setOperatorKind(OperatorKind value) {
opKind = Optional.of(value);
return this;
}
public IRNodeBuilder setLevel(int value) {
level = Optional.of(value);
return this;
}
public IRNodeBuilder setSubBlock(boolean value) {
subBlock = Optional.of(value);
return this;
}
public IRNodeBuilder setCanHaveBreaks(boolean value) {
canHaveBreaks = Optional.of(value);
return this;
}
public IRNodeBuilder setCanHaveContinues(boolean value) {
canHaveContinues = Optional.of(value);
return this;
}
public IRNodeBuilder setCanHaveReturn(boolean value) {
canHaveReturn = Optional.of(value);
return this;
}
public IRNodeBuilder setCanHaveThrow(boolean value) {
canHaveThrow = Optional.of(value);
return this;
}
public IRNodeBuilder setPrefix(String value) {
prefix = Optional.of(value);
return this;
}
public IRNodeBuilder setMemberFunctionsLimit(int value) {
memberFunctionsLimit = Optional.of(value);
return this;
}
public IRNodeBuilder setMemberFunctionsArgLimit(int value) {
memberFunctionsArgLimit = Optional.of(value);
return this;
}
public IRNodeBuilder setLocalVariable(LocalVariable value) {
localVariable = Optional.of(value);
return this;
}
public IRNodeBuilder setIsLocal(boolean value) {
isLocal = Optional.of(value);
return this;
}
public IRNodeBuilder setIsStatic(boolean value) {
isStatic = Optional.of(value);
return this;
}
public IRNodeBuilder setIsInitialized(boolean value) {
isInitialized = Optional.of(value);
return this;
}
public IRNodeBuilder setIsConstant(boolean value) {
isConstant = Optional.of(value);
return this;
}
public IRNodeBuilder setName(String value) {
name = Optional.of(value);
return this;
}
public IRNodeBuilder setFlags(int value) {
flags = Optional.of(value);
return this;
}
public IRNodeBuilder setFunctionInfo(FunctionInfo value) {
functionInfo = Optional.of(value);
return this;
}
public IRNodeBuilder setSemicolon(boolean value) {
semicolon = Optional.of(value);
return this;
}
// getters
/* private Type getVariableType() {
return variableType.orElseThrow(() -> new IllegalArgumentException(
"Variable type wasn't set"));
}*/
private TypeKlass getArgumentType() {
return argumentType.orElseThrow(() -> new IllegalArgumentException(
"Argument type wasn't set"));
}
private int getVariableNumber() {
return variableNumber.orElseThrow(() -> new IllegalArgumentException(
"Variable number wasn't set"));
}
private long getComplexityLimit() {
return complexityLimit.orElseThrow(() -> new IllegalArgumentException(
"Complexity limit wasn't set"));
}
private int getOperatorLimit() {
return operatorLimit.orElseThrow(() -> new IllegalArgumentException(
"Operator limit wasn't set"));
}
private int getStatementLimit() {
return statementLimit.orElseThrow(() -> new IllegalArgumentException(
"Statement limit wasn't set"));
}
private TypeKlass getOwnerClass() {
return ownerClass.orElseThrow(() -> new IllegalArgumentException("Type_Klass wasn't set"));
}
private Type getResultType() {
return resultType.orElseThrow(() -> new IllegalArgumentException("Return type wasn't set"));
}
private boolean getExceptionSafe() {
return safe.orElseThrow(() -> new IllegalArgumentException("Safe wasn't set"));
}
private boolean getNoConsts() {
return noConsts.orElseThrow(() -> new IllegalArgumentException("NoConsts wasn't set"));
}
private OperatorKind getOperatorKind() {
return opKind.orElseThrow(() -> new IllegalArgumentException("Operator kind wasn't set"));
}
private int getLevel() {
return level.orElseThrow(() -> new IllegalArgumentException("Level wasn't set"));
}
private String getPrefix() {
return prefix.orElseThrow(() -> new IllegalArgumentException("Prefix wasn't set"));
}
private int getMemberFunctionsLimit() {
return memberFunctionsLimit.orElseThrow(() -> new IllegalArgumentException(
"memberFunctions limit wasn't set"));
}
private int getMemberFunctionsArgLimit() {
return memberFunctionsArgLimit.orElseThrow(() -> new IllegalArgumentException(
"memberFunctionsArg limit wasn't set"));
}
private LocalVariable getLocalVariable() {
return localVariable.orElseThrow(() -> new IllegalArgumentException(
"local variable wasn't set"));
}
private boolean getIsLocal() {
return isLocal.orElseThrow(() -> new IllegalArgumentException("isLocal wasn't set"));
}
private boolean getIsStatic() {
return isStatic.orElseThrow(() -> new IllegalArgumentException("isStatic wasn't set"));
}
private boolean getIsInitialized() {
return isInitialized.orElseThrow(() -> new IllegalArgumentException(
"isInitialized wasn't set"));
}
private boolean getIsConstant() {
return isConstant.orElseThrow(() -> new IllegalArgumentException("isConstant wasn't set"));
}
private boolean getCanHaveReturn() {
return canHaveReturn.orElseThrow(() -> new IllegalArgumentException(
"canHaveReturn wasn't set"));
}
private boolean getCanHaveBreaks() {
return canHaveBreaks.orElseThrow(() -> new IllegalArgumentException(
"canHaveBreaks wasn't set"));
}
private boolean getCanHaveContinues() {
return canHaveContinues.orElseThrow(() -> new IllegalArgumentException(
"canHaveContinues wasn't set"));
}
private String getName() {
return name.orElseThrow(() -> new IllegalArgumentException("Name wasn't set"));
}
private int getFlags() {
return flags.orElseThrow(() -> new IllegalArgumentException("Flags wasn't set"));
}
private FunctionInfo getFunctionInfo() {
return functionInfo.orElseThrow(() -> new IllegalArgumentException(
"FunctionInfo wasn't set"));
}
}