Examples with ExprNode kalang.ast.ExprNode used on opensource projects

Example 36 with ExprNode

use of kalang.ast.ExprNode in project kalang by kasonyang.

the class AstBuilder method visitQuestionExpr.

@Override
public AstNode visitQuestionExpr(KalangParser.QuestionExprContext ctx) {
    List<Statement> stmts = new LinkedList<>();
    ExprNode conditionExpr = (ExprNode) visit(ctx.expression(0));
    ExprNode trueExpr = (ExprNode) visit(ctx.expression(1));
    ExprNode falseExpr = (ExprNode) visit(ctx.expression(2));
    Type trueType = trueExpr.getType();
    Type falseType = falseExpr.getType();
    Type type;
    if (trueType.equals(falseType)) {
        type = trueType;
    } else {
        type = TypeUtil.getCommonType(trueType, falseType);
    }
    LocalVarNode vo = this.declareTempLocalVar(type);
    VarDeclStmt vds = new VarDeclStmt(vo);
    stmts.add(vds);
    VarExpr ve = new VarExpr(vo);
    IfStmt is = new IfStmt(conditionExpr);
    is.getTrueBody().statements.add(new ExprStmt(new AssignExpr(ve, trueExpr)));
    is.getFalseBody().statements.add(new ExprStmt(new AssignExpr(ve, falseExpr)));
    stmts.add(is);
    MultiStmtExpr mse = new MultiStmtExpr(stmts, ve);
    mapAst(ve, ctx);
    return mse;
}

Example 37 with ExprNode

use of kalang.ast.ExprNode in project kalang by kasonyang.

the class AstBuilder method visitForEachStat.

@Override
public Object visitForEachStat(KalangParser.ForEachStatContext ctx) {
    BlockStmt block = newBlock();
    ExprNode expr = this.visitExpression(ctx.expression());
    Type exprType = expr.getType();
    List<TerminalNode> idsCtx = ctx.Identifier();
    VarExpr indexVarExpr = null;
    TerminalNode varId;
    if (idsCtx.size() == 1) {
        varId = idsCtx.get(0);
    } else {
        TerminalNode indexId = idsCtx.get(0);
        LocalVarNode indexVar = this.declareLocalVar(indexId.getText(), Types.INT_TYPE, Modifier.FINAL, ctx);
        if (indexVar == null)
            return null;
        block.statements.add(new VarDeclStmt(indexVar));
        indexVarExpr = new VarExpr(indexVar);
        varId = idsCtx.get(1);
    }
    LoopStmt loopStmt;
    if (exprType instanceof ArrayType) {
        LocalVarNode localVarNode = this.declareLocalVar(varId.getText(), ((ArrayType) exprType).getComponentType(), Modifier.FINAL, ctx);
        if (localVarNode == null)
            return null;
        VarExpr localVariable = new VarExpr(localVarNode);
        block.statements.add(new VarDeclStmt(localVarNode));
        LocalVarNode lenVar = this.declareTempLocalVar(Types.INT_TYPE);
        LocalVarNode counterVar = this.declareTempLocalVar(Types.INT_TYPE);
        // var len
        block.statements.add(new VarDeclStmt(lenVar));
        // var i
        block.statements.add(new VarDeclStmt(counterVar));
        VarExpr counterVarExpr = new VarExpr(counterVar);
        VarExpr lenVarExpr = new VarExpr(lenVar);
        block.statements.add(new ExprStmt(new AssignExpr(lenVarExpr, new ArrayLengthExpr(expr))));
        // l = array.length
        block.statements.add(new ExprStmt(new AssignExpr(counterVarExpr, new ConstExpr(0))));
        // i=0
        ExprNode cnd = new CompareExpr(counterVarExpr, lenVarExpr, CompareExpr.OP_LT);
        BlockStmt loopBody = this.newBlock();
        loopBody.statements.add(new ExprStmt(new AssignExpr(localVariable, new ElementExpr(expr, counterVarExpr))));
        if (indexVarExpr != null) {
            loopBody.statements.add(new ExprStmt(new AssignExpr(indexVarExpr, counterVarExpr)));
        }
        loopBody.statements.add(visitStat(ctx.stat()));
        popBlock();
        BlockStmt updateBs = newBlock();
        // increment counter
        updateBs.statements.add(new ExprStmt(new AssignExpr(counterVarExpr, new MathExpr(counterVarExpr, new ConstExpr(1), MathExpr.OP_ADD))));
        popBlock();
        loopStmt = new LoopStmt(cnd, null, loopBody, updateBs);
    } else {
        ObjectType iterType = Types.getIterableClassType();
        if (iterType.isAssignableFrom(exprType)) {
            ObjectInvokeExpr getIterableExpr;
            try {
                getIterableExpr = ObjectInvokeExpr.create(expr, "iterator", null);
            } catch (MethodNotFoundException | AmbiguousMethodException ex) {
                throw Exceptions.unexceptedException(ex);
            }
            LocalVarNode iterableVarNode = this.declareTempLocalVar(getIterableExpr.getType());
            block.statements.add(new VarDeclStmt(iterableVarNode));
            VarExpr iterableVarExpr = new VarExpr(iterableVarNode);
            block.statements.add(new ExprStmt(new AssignExpr(iterableVarExpr, getIterableExpr)));
            // set index = 0
            if (indexVarExpr != null) {
                block.statements.add(new ExprStmt(new AssignExpr(indexVarExpr, new ConstExpr(0))));
            }
            ObjectInvokeExpr cnd;
            try {
                cnd = ObjectInvokeExpr.create(iterableVarExpr, "hasNext", null);
            } catch (MethodNotFoundException | AmbiguousMethodException ex) {
                throw Exceptions.unexceptedException(ex);
            }
            BlockStmt loopBody = this.newBlock();
            ObjectInvokeExpr nextInvokeExpr;
            try {
                nextInvokeExpr = ObjectInvokeExpr.create(iterableVarExpr, "next", null);
            } catch (MethodNotFoundException | AmbiguousMethodException ex) {
                throw Exceptions.unexceptedException(ex);
            }
            LocalVarNode localVarNode = this.declareLocalVar(varId.getText(), nextInvokeExpr.getType(), Modifier.FINAL, ctx);
            if (localVarNode == null)
                return null;
            VarExpr localVariable = new VarExpr(localVarNode);
            loopBody.statements.add(new VarDeclStmt(localVarNode));
            loopBody.statements.add(new ExprStmt(new AssignExpr(localVariable, new CastExpr(localVariable.getType(), nextInvokeExpr))));
            loopBody.statements.add(visitStat(ctx.stat()));
            popBlock();
            BlockStmt updateBs = newBlock();
            if (indexVarExpr != null) {
                // do index++
                updateBs.statements.add(new ExprStmt(new AssignExpr(indexVarExpr, new MathExpr(indexVarExpr, new ConstExpr(1), BinaryExpr.OP_ADD))));
            }
            popBlock();
            loopStmt = new LoopStmt(cnd, null, loopBody, updateBs);
        } else {
            this.handleSyntaxError("require array type or iterable type", ctx.expression());
            loopStmt = null;
        }
    }
    popBlock();
    if (loopStmt != null)
        block.statements.add(loopStmt);
    return block;
}

Example 38 with ExprNode

use of kalang.ast.ExprNode in project kalang by kasonyang.

the class AstBuilder method getStaticInvokeExpr.

private ExprNode getStaticInvokeExpr(ClassReference clazz, String methodName, ExprNode[] argumentsCtx, ParserRuleContext ctx) {
    ExprNode[] args = argumentsCtx;
    ExprNode expr;
    try {
        expr = StaticInvokeExpr.create(clazz, methodName, args);
    } catch (MethodNotFoundException ex) {
        methodNotFound(ctx.start, className, methodName, args);
        expr = new UnknownInvocationExpr(clazz, methodName, args);
    } catch (AmbiguousMethodException ex) {
        methodIsAmbiguous(ctx.start, ex);
        return null;
    }
    mapAst(expr, ctx);
    return expr;
}

Example 39 with ExprNode

use of kalang.ast.ExprNode in project kalang by kasonyang.

the class AstBuilder method visitMemberInvocationExpr.

@Override
public ExprNode visitMemberInvocationExpr(MemberInvocationExprContext ctx) {
    String methodName;
    ExprNode target;
    ObjectType clazz;
    if (ctx.key != null) {
        methodName = ctx.key.getText();
    } else {
        methodName = ctx.Identifier().getText();
    }
    if (methodName.equals("this")) {
        methodName = "<init>";
        target = new ThisExpr(this.getThisType());
        clazz = this.getThisType();
    } else if (methodName.equals("super")) {
        methodName = "<init>";
        target = new SuperExpr(thisClazz);
        clazz = thisClazz.getSuperType();
    } else {
        target = new ThisExpr(this.getThisType());
        clazz = this.getThisType();
    }
    List<Object> argsList = visitAll(ctx.params);
    if (argsList.contains(null))
        return null;
    ExprNode[] args = argsList.toArray(new ExprNode[argsList.size()]);
    ExprNode ie;
    if (methodName.equals("<init>")) {
        if (clazz == null)
            throw Exceptions.unexceptedValue(clazz);
        try {
            InvocationExpr.MethodSelection apply = InvocationExpr.applyMethod(clazz, methodName, args, clazz.getConstructorDescriptors(thisClazz));
            ie = new ObjectInvokeExpr(target, apply.selectedMethod, apply.appliedArguments);
        } catch (MethodNotFoundException | AmbiguousMethodException ex) {
            this.methodNotFound(ctx.start, clazz.getName(), methodName, args);
            return null;
        }
    } else {
        ie = getImplicitInvokeExpr(methodName, args, ctx);
    }
    return ie;
}

Example 40 with ExprNode

use of kalang.ast.ExprNode in project kalang by kasonyang.

the class AstBuilder method createBinaryExpr.

private ExprNode createBinaryExpr(String op, ExpressionContext exprCtx1, ExpressionContext exprCtx2, Token opStart, Token opEnd, ParserRuleContext ctx) {
    ExprNode expr1 = visitExpression(exprCtx1);
    ExprNode expr2 = visitExpression(exprCtx2);
    Type type1 = expr1.getType();
    Type type2 = expr2.getType();
    boolean isPrimitive1 = (type1 instanceof PrimitiveType);
    boolean isPrimitive2 = (type2 instanceof PrimitiveType);
    ExprNode expr;
    if (isPrimitive1 && isPrimitive2) {
        expr = createBinaryExpr(expr1, expr2, op);
    } else if (Types.isNumber(type1) && Types.isNumber(type2)) {
        PrimitiveType t = SemanticAnalyzer.getMathType(type1, type2, op);
        expr1 = BoxUtil.assign(expr1, type1, t);
        expr2 = BoxUtil.assign(expr2, type2, t);
        if (expr1 == null)
            throw Exceptions.unexceptedValue(expr1);
        if (expr2 == null)
            throw Exceptions.unexceptedValue(expr2);
        expr = createBinaryExpr(expr1, expr2, op);
    } else if (op.equals("==") || op.equals("!=")) {
        expr = createBinaryExpr(expr1, expr2, op);
    } else if (op.equals("+")) {
        expr = this.concatExpressionsToStringExpr(new ExprNode[] { expr1, expr2 }, new Token[] { exprCtx1.getStart(), exprCtx2.getStart() });
    } else {
        handleSyntaxError("unsupported operation", ParserRuleContext.EMPTY, opStart, opEnd);
        return null;
    }
    if (expr != null)
        mapAst(expr, ctx);
    return expr;
}