private IRDest attach_Factor(SymbolTable scope, MicroParser.FactorContext factor) {
if (factor == null) return null;
// if left subtree is empty
if (factor.factor_prefix().children == null) {
// search right subtree
// System.out.println("Searching postfix_expr");
IRDest d = attach_PostfixExpr(scope, factor.postfix_expr());
/// System.out.print("PostfixExpr returned: ");
/// System.out.print(d);
/// System.out.println();
return d;
}
// left subtree isn't empty, search it for
IRDest fp = attach_FactorPrefix(scope, factor.factor_prefix());
// do the same for the right subtree
IRDest postfix = attach_PostfixExpr(scope, factor.postfix_expr());
// join two subtrees into one IR node
IRNode K = null;
Instruction op =
ISA.transform_type(ISA.MULTI, fp.getDataTypePrecedence(), postfix.getDataTypePrecedence());
if (factor.factor_prefix().mulop().getText().equals("/")) {
op =
ISA.transform_type(ISA.DIVI, fp.getDataTypePrecedence(), postfix.getDataTypePrecedence());
}
Register dest = TempRegisterFactory.create(op.supported_type);
if (fp._id != null && postfix._id != null) {
K = new IRNode(op, fp._id, postfix._id, dest);
} else if (fp._reg != null && postfix._reg != null) {
K = new IRNode(op, fp._reg, postfix._reg, dest);
} else if (fp._id != null && postfix._reg != null) {
K = new IRNode(op, fp._id, postfix._reg, dest);
} else if (fp._reg != null && postfix._id != null) {
K = new IRNode(op, fp._reg, postfix._id, dest);
} else {
System.err.println("Something gone wrong");
}
_List.add(K);
return new IRDest(dest);
}
/*
* Left hand side of ADD
*/
public IRDest attach_ExprPrefix(SymbolTable scope, MicroParser.Expr_prefixContext expr_prefix) {
if (expr_prefix.children == null) return null;
if (expr_prefix.expr_prefix().children == null) {
// has no more left recursion, so we go right
return attach_Factor(scope, expr_prefix.factor());
}
IRDest left = attach_ExprPrefix(scope, expr_prefix.expr_prefix());
IRDest right = attach_Factor(scope, expr_prefix.factor());
// TODO: handle case where right of expression is lambda
IRNode irn = null;
Instruction op =
ISA.transform_type(ISA.ADDI, left.getDataTypePrecedence(), right.getDataTypePrecedence());
Register dest = TempRegisterFactory.create(op.supported_type);
if (expr_prefix.expr_prefix().addop().getText().equals("-")) op = ISA.SUBI;
if (left._id != null && right._id != null) {
irn = new IRNode(op, left._id, right._id, dest);
} else if (left._reg != null && right._reg != null) {
irn = new IRNode(op, left._reg, right._reg, dest);
} else if (left._id != null && right._reg != null) {
irn = new IRNode(op, left._id, right._reg, dest);
} else if (left._reg != null && right._id != null) {
irn = new IRNode(op, left._reg, right._id, dest);
} else {
System.err.println("Something went wrong");
}
_List.add(irn);
return new IRDest(dest);
}
/*
* Generate expression IR nodes and add them to IR list
* @param scope : the current scope
* @param ctx: the expression parse subtree context
* @return last node in the list
*/
public IRDest attach_Expressions(SymbolTable scope, MicroParser.ExprContext expr) {
IRDest dleft = attach_ExprPrefix(scope, expr.expr_prefix());
IRDest dright = attach_Factor(scope, expr.factor());
if (dleft == null && dright == null) {
return null;
}
if (dleft == null) {
return dright;
}
if (dright == null) {
return dleft;
}
IRNode N = null;
Instruction op =
ISA.transform_type(ISA.ADDI, dleft.getDataTypePrecedence(), dright.getDataTypePrecedence());
if (expr.expr_prefix().addop().getText().equals("-"))
op =
ISA.transform_type(
ISA.SUBI, dleft.getDataTypePrecedence(), dright.getDataTypePrecedence());
Register dest = TempRegisterFactory.create(op.supported_type);
if (dleft._reg != null && dright._reg != null) {
N = new IRNode(op, dleft._reg, dright._reg, dest);
} else if (dleft._id != null && dright._id != null) {
N = new IRNode(op, dleft._id, dright._id, dest);
} else if (dleft._id != null && dright._reg != null) {
N = new IRNode(op, dleft._id, dright._reg, dest);
} else if (dleft._reg != null && dright._id != null) {
N = new IRNode(op, dleft._reg, dright._id, dest);
}
_List.add(N);
return new IRDest(dest);
}
public class IsAEvaluatorDefinition extends org.drools.base.evaluators.IsAEvaluatorDefinition {
public static final Operator ISA_IMP =
Operator.addOperatorToRegistry(ChanceOperators.makeImperfect("isA"), false);
public static final Operator NOT_ISA_IMP =
Operator.addOperatorToRegistry(ChanceOperators.makeImperfect("isA"), true);
private static final String[] CHANCE_IDS =
new String[] {ISA.getOperatorString(), ISA_IMP.getOperatorString()};
/** @inheridDoc */
public String[] getEvaluatorIds() {
return CHANCE_IDS;
}
/** @inheridDoc */
public Evaluator getEvaluator(ValueType type, Operator operator) {
return this.getEvaluator(type, operator.getOperatorString(), operator.isNegated(), null);
}
/** @inheridDoc */
public Evaluator getEvaluator(ValueType type, Operator operator, String parameterText) {
return this.getEvaluator(
type, operator.getOperatorString(), operator.isNegated(), parameterText);
}
/** @inheridDoc */
public Evaluator getEvaluator(
ValueType type, String operatorId, boolean isNegated, String parameterText) {
return getEvaluator(type, operatorId, isNegated, parameterText, Target.FACT, Target.FACT);
}
/** @inheridDoc */
public Evaluator getEvaluator(
ValueType type,
String operatorId,
boolean isNegated,
String parameterText,
Target leftTarget,
Target rightTarget) {
if (ChanceOperators.isImperfect(operatorId)) {
if (isNegated) {
throw new UnsupportedOperationException("Negated isA : Not implemented yet");
}
IsAEvaluator evaluator = new ImperfectIsAEvaluator(type, isNegated);
evaluator.setParameterText(parameterText);
return evaluator;
} else {
IsAEvaluator evaluator = new IsAEvaluator(type, isNegated);
evaluator.setParameterText(parameterText);
return evaluator;
}
}
public static class ImperfectIsAEvaluator extends IsAEvaluator implements ImperfectEvaluator {
public ImperfectIsAEvaluator(ValueType type, boolean negated) {
super(type, negated);
}
public Degree match(InternalWorkingMemory workingMemory, Object object, String typeName) {
TraitableBean core = null;
if (object instanceof Thing) {
Thing thing = (Thing) object;
core = (TraitableBean) thing.getCore();
if (core.hasTrait(typeName)) {
Thing proxy = core.getTrait(typeName.toString());
return extractDegree(proxy);
} else {
return ChanceDegreeTypeRegistry.getSingleInstance().getDefaultOne().False();
}
} else if (object instanceof TraitableBean) {
core = (TraitableBean) object;
if (core.hasTrait(typeName)) {
Thing proxy = core.getTrait(typeName.toString());
return extractDegree(proxy);
} else {
return ChanceDegreeTypeRegistry.getSingleInstance().getDefaultOne().False();
}
} else {
core = lookForWrapper(object, workingMemory);
if (core == null || !core.hasTrait(typeName)) {
return ChanceDegreeTypeRegistry.getDefaultOne().False();
} else {
Thing proxy = core.getTrait(typeName.toString());
return extractDegree(proxy);
}
}
}
public Degree match(
InternalWorkingMemory workingMemory,
InternalReadAccessor extractor,
Object object,
FieldValue value) {
Object typeName = value.getValue();
if (typeName instanceof Class) {
typeName = ((Class) typeName).getName();
}
return match(workingMemory, object, (String) typeName);
}
private Degree extractDegree(Thing proxy) {
if (proxy == null) {
return ChanceDegreeTypeRegistry.getSingleInstance().getDefaultOne().False();
} else {
if (proxy instanceof ImperfectTraitProxy) {
return ((ImperfectTraitProxy) proxy).isA();
} else {
return ChanceDegreeTypeRegistry.getSingleInstance().getDefaultOne().True();
}
}
}
public Degree match(
InternalWorkingMemory workingMemory,
InternalReadAccessor leftExtractor,
Object left,
InternalReadAccessor rightExtractor,
Object right) {
throw new UnsupportedOperationException("Not implemented yet");
}
public Degree matchCachedLeft(
InternalWorkingMemory workingMemory,
VariableRestriction.VariableContextEntry context,
Object right) {
throw new UnsupportedOperationException("Not implemented yet");
}
public Degree matchCachedRight(
InternalWorkingMemory workingMemory,
VariableRestriction.VariableContextEntry context,
Object left) {
throw new UnsupportedOperationException("Not implemented yet");
}
}
}
