@Override public String toString() { return String.valueOf(this.lhsExpr) + " " + this.opKind.value() + " " + this.targetType; } }
void createBinaryExpr(DiagnosticPos pos, Set<Whitespace> ws, String operator) { BLangBinaryExpr binaryExpressionNode = (BLangBinaryExpr) TreeBuilder.createBinaryExpressionNode(); binaryExpressionNode.pos = pos; binaryExpressionNode.addWS(ws); binaryExpressionNode.rhsExpr = (BLangExpression) exprNodeStack.pop(); binaryExpressionNode.lhsExpr = (BLangExpression) exprNodeStack.pop(); binaryExpressionNode.opKind = OperatorKind.valueFrom(operator); addExpressionNode(binaryExpressionNode); }
public static OperatorKind valueFrom(String opValue) { for (OperatorKind operatorKind : OperatorKind.values()) { if (operatorKind.opValue.equals(opValue)) { return operatorKind; } } return null; } }
public void visit(BLangUnaryExpr unaryExpr) { RegIndex exprIndex = calcAndGetExprRegIndex(unaryExpr); if (OperatorKind.ADD.equals(unaryExpr.operator) || OperatorKind.UNTAINT.equals(unaryExpr.operator)) { unaryExpr.expr.regIndex = createLHSRegIndex(unaryExpr.regIndex); genNode(unaryExpr.expr, this.env); return; } int opcode; genNode(unaryExpr.expr, this.env); if (OperatorKind.LENGTHOF.equals(unaryExpr.operator)) { Operand typeCPIndex = getTypeCPIndex(unaryExpr.expr.type); opcode = unaryExpr.opSymbol.opcode; emit(opcode, unaryExpr.expr.regIndex, typeCPIndex, exprIndex); } else { opcode = unaryExpr.opSymbol.opcode; emit(opcode, unaryExpr.expr.regIndex, exprIndex); } }
@Override public void visit(BLangBinaryExpr binaryExpr) { if (OperatorKind.AND.equals(binaryExpr.opKind)) { visitAndExpression(binaryExpr); } else if (OperatorKind.OR.equals(binaryExpr.opKind)) { visitOrExpression(binaryExpr); } else if (binaryExpr.opSymbol.opcode == InstructionCodes.REQ_NULL || binaryExpr.opSymbol.opcode == InstructionCodes.RNE_NULL) { BLangExpression expr = (binaryExpr.lhsExpr.type.tag == TypeTags.NIL) ? binaryExpr.rhsExpr : binaryExpr.lhsExpr; genNode(expr, this.env); emit(binaryExpr.opSymbol.opcode, expr.regIndex, calcAndGetExprRegIndex(binaryExpr)); } else { genNode(binaryExpr.lhsExpr, this.env); genNode(binaryExpr.rhsExpr, this.env); RegIndex regIndex = calcAndGetExprRegIndex(binaryExpr); int opCode = binaryExpr.opSymbol.opcode; emit(opCode, binaryExpr.lhsExpr.regIndex, binaryExpr.rhsExpr.regIndex, regIndex); } }
private InstructionKind getBinaryInstructionKind(OperatorKind opKind) { switch (opKind) { case ADD: return InstructionKind.ADD; case SUB: return InstructionKind.SUB; case MUL: return InstructionKind.MUL; case DIV: return InstructionKind.DIV; case MOD: return InstructionKind.MOD; case EQUAL: return InstructionKind.EQUAL; case NOT_EQUAL: return InstructionKind.NOT_EQUAL; case GREATER_THAN: return InstructionKind.GREATER_THAN; case GREATER_EQUAL: return InstructionKind.GREATER_EQUAL; case LESS_THAN: return InstructionKind.LESS_THAN; case LESS_EQUAL: return InstructionKind.LESS_EQUAL; default: throw new IllegalStateException("unsupported binary operation: " + opKind.value()); } } }
void createUnaryExpr(DiagnosticPos pos, Set<Whitespace> ws, String operator) { BLangUnaryExpr unaryExpressionNode = (BLangUnaryExpr) TreeBuilder.createUnaryExpressionNode(); unaryExpressionNode.pos = pos; unaryExpressionNode.addWS(ws); unaryExpressionNode.expr = (BLangExpression) exprNodeStack.pop(); unaryExpressionNode.operator = OperatorKind.valueFrom(operator); addExpressionNode(unaryExpressionNode); }
public void visit(BLangUnaryExpr unaryExpr) { BType exprType; BType actualType = symTable.semanticError; if (OperatorKind.UNTAINT.equals(unaryExpr.operator)) { exprType = checkExpr(unaryExpr.expr, env); if (exprType != symTable.semanticError) { actualType = exprType; } } else { exprType = checkExpr(unaryExpr.expr, env); if (exprType != symTable.semanticError) { BSymbol symbol = symResolver.resolveUnaryOperator(unaryExpr.pos, unaryExpr.operator, exprType); if (symbol == symTable.notFoundSymbol) { dlog.error(unaryExpr.pos, DiagnosticCode.UNARY_OP_INCOMPATIBLE_TYPES, unaryExpr.operator, exprType); } else { unaryExpr.opSymbol = (BOperatorSymbol) symbol; actualType = symbol.type.getReturnType(); } } } resultType = types.checkType(unaryExpr, actualType, expType); }
private void defineUnaryOperator(OperatorKind kind, BType type, BType retType, int opcode) { List<BType> paramTypes = Lists.of(type); defineOperator(names.fromString(kind.value()), paramTypes, retType, opcode); }
void addCompoundAssignmentStatement(DiagnosticPos pos, Set<Whitespace> ws, String operator) { BLangCompoundAssignment assignmentNode = (BLangCompoundAssignment) TreeBuilder.createCompoundAssignmentNode(); assignmentNode.setExpression(exprNodeStack.pop()); assignmentNode.setVariable((BLangVariableReference) exprNodeStack.pop()); assignmentNode.pos = pos; assignmentNode.addWS(ws); assignmentNode.addWS(this.operatorWs.pop()); assignmentNode.opKind = OperatorKind.valueFrom(operator); addStmtToCurrentBlock(assignmentNode); }
private void defineBinaryOperator(OperatorKind kind, BType lhsType, BType rhsType, BType retType, int opcode) { List<BType> paramTypes = Lists.of(lhsType, rhsType); defineOperator(names.fromString(kind.value()), paramTypes, retType, opcode); }
public BSymbol resolveUnaryOperator(DiagnosticPos pos, OperatorKind opKind, BType type) { return resolveOperator(names.fromString(opKind.value()), Lists.of(type)); }
static BLangIsAssignableExpr createIsAssignableExpr(DiagnosticPos pos, BLangExpression lhsExpr, BType targetType, BType type, Names names) { final BLangIsAssignableExpr assignableExpr = new BLangIsAssignableExpr(); assignableExpr.pos = pos; assignableExpr.lhsExpr = lhsExpr; assignableExpr.targetType = targetType; assignableExpr.type = type; assignableExpr.opSymbol = new BOperatorSymbol(names.fromString(assignableExpr.opKind.value()), null, targetType, null, InstructionCodes.IS_ASSIGNABLE); return assignableExpr; }
public BSymbol resolveBinaryOperator(OperatorKind opKind, BType lhsType, BType rhsType) { BSymbol bSymbol = resolveOperator(names.fromString(opKind.value()), Lists.of(lhsType, rhsType)); if (bSymbol == symTable.notFoundSymbol) { bSymbol = getBinaryOpForNullChecks(opKind, lhsType, rhsType); } return bSymbol; }
BSymbol createEqualityOperator(OperatorKind opKind, BType lhsType, BType rhsType) { int opcode; if (opKind == OperatorKind.REF_EQUAL) { opcode = InstructionCodes.REF_EQ; } else if (opKind == OperatorKind.REF_NOT_EQUAL) { opcode = InstructionCodes.REF_NEQ; } else if (opKind == OperatorKind.EQUAL) { opcode = InstructionCodes.REQ; } else { // OperatorKind.NOT_EQUAL opcode = InstructionCodes.RNE; } List<BType> paramTypes = Lists.of(lhsType, rhsType); BType retType = symTable.booleanType; BInvokableType opType = new BInvokableType(paramTypes, retType, null); return new BOperatorSymbol(names.fromString(opKind.value()), null, opType, null, opcode); }
private BSymbol getBinaryOpForNullChecks(OperatorKind opKind, BType lhsType, BType rhsType) { if (opKind != OperatorKind.EQUAL && opKind != OperatorKind.NOT_EQUAL) { return symTable.notFoundSymbol; } int opcode = (opKind == OperatorKind.EQUAL) ? InstructionCodes.REQ_NULL : InstructionCodes.RNE_NULL; if (lhsType.tag == TypeTags.NIL && (rhsType.tag == TypeTags.OBJECT || rhsType.tag == TypeTags.RECORD || rhsType.tag == TypeTags.INVOKABLE)) { BInvokableType opType = new BInvokableType(Lists.of(lhsType, rhsType), symTable.booleanType, null); return new BOperatorSymbol(names.fromString(opKind.value()), null, opType, null, opcode); } if ((lhsType.tag == TypeTags.OBJECT || lhsType.tag == TypeTags.RECORD || lhsType.tag == TypeTags.INVOKABLE) && rhsType.tag == TypeTags.NIL) { BInvokableType opType = new BInvokableType(Lists.of(lhsType, rhsType), symTable.booleanType, null); return new BOperatorSymbol(names.fromString(opKind.value()), null, opType, null, opcode); } return symTable.notFoundSymbol; }
BOperatorSymbol operatorSymbol = new BOperatorSymbol(names.fromString(OperatorKind.NOT.value()), symTable.rootPkgSymbol.pkgID, type, symTable.rootPkgSymbol, InstructionCodes.BNOT); BLangUnaryExpr unaryExpr = ASTBuilderUtil.createUnaryExpr(resourceNode.pos, filterRequestInvocation,