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

Example 1 with Statement

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

the class Ast2Class method visit.

@Override
public Object visit(AstNode node) {
    int lineNum = node.offset.startLine;
    if (lineNum > 0 && (node instanceof Statement || node instanceof ExprNode) && !lineLabels.containsKey(lineNum)) {
        Label lb = new Label();
        md.visitLabel(lb);
        md.visitLineNumber(lineNum, lb);
        lineLabels.put(lineNum, lb);
    }
    return super.visit(node);
}

Example 2 with Statement

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

the class AstBuilder method visitMapExpr.

@Override
public MultiStmtExpr visitMapExpr(KalangParser.MapExprContext ctx) {
    Type keyType = ctx.keyType != null ? requireClassType(ctx.keyType) : Types.getRootType();
    Type valueType = ctx.valueType != null ? requireClassType(ctx.valueType) : Types.getRootType();
    if (keyType == null || valueType == null)
        return null;
    LocalVarNode vo = declareTempLocalVar(Types.getClassType(Types.getMapImplClassType().getClassNode(), new Type[] { keyType, valueType }));
    VarDeclStmt vds = new VarDeclStmt(vo);
    NewObjectExpr newExpr;
    try {
        newExpr = new NewObjectExpr(Types.getMapImplClassType());
    } catch (MethodNotFoundException | AmbiguousMethodException ex) {
        throw Exceptions.unexceptedException(ex);
    }
    List<Statement> stmts = new LinkedList<>();
    stmts.add(vds);
    stmts.add(new ExprStmt(new AssignExpr(new VarExpr(vo), newExpr)));
    VarExpr ve = new VarExpr(vo);
    List<TerminalNode> ids = ctx.Identifier();
    for (int i = 0; i < ids.size(); i++) {
        ExpressionContext e = ctx.expression(i);
        ExprNode v = (ExprNode) visit(e);
        ConstExpr k = new ConstExpr(ctx.Identifier(i).getText());
        ExprNode[] args = new ExprNode[] { k, v };
        InvocationExpr iv;
        try {
            iv = ObjectInvokeExpr.create(ve, "put", args);
        } catch (MethodNotFoundException | AmbiguousMethodException ex) {
            throw Exceptions.unexceptedException(ex);
        }
        ExprStmt es = new ExprStmt(iv);
        stmts.add(es);
    }
    MultiStmtExpr mse = new MultiStmtExpr(stmts, ve);
    mapAst(mse, ctx);
    return mse;
}

Example 3 with Statement

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

the class AstBuilder method visitForStat.

@Override
public AstNode visitForStat(ForStatContext ctx) {
    // TODO It seems that here lacks of var stack
    BlockStmt forStmt = newBlock();
    if (ctx.localVarDecl() != null) {
        Statement vars = visitLocalVarDecl(ctx.localVarDecl());
        forStmt.statements.add(vars);
    }
    if (ctx.initExpressions != null) {
        forStmt.statements.addAll(visitExpressions(ctx.initExpressions));
    }
    ExprNode preConditionExpr = ctx.condition != null ? visitExpression(ctx.condition) : null;
    BlockStmt bs = newBlock();
    if (ctx.stat() != null) {
        Statement st = visitStat(ctx.stat());
        if (st instanceof BlockStmt) {
            bs.statements.addAll(((BlockStmt) st).statements);
        }
    }
    popBlock();
    BlockStmt updateBs = newBlock();
    if (ctx.updateExpressions != null) {
        updateBs.statements.addAll(visitExpressions(ctx.updateExpressions));
    }
    popBlock();
    LoopStmt ls = new LoopStmt(preConditionExpr, null, bs, updateBs);
    mapAst(ls, ctx);
    forStmt.statements.add(ls);
    popBlock();
    return forStmt;
}

Example 4 with Statement

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

the class AstBuilder method visitInvokeExpr.

@Override
public AstNode visitInvokeExpr(InvokeExprContext ctx) {
    Object target = visit(ctx.target);
    if (target == null)
        return null;
    String mdName = ctx.Identifier().getText();
    String refKey = ctx.refKey.getText();
    if (refKey.equals(".")) {
        if (target instanceof ClassReference) {
            return getStaticInvokeExpr((ClassReference) target, mdName, ctx.params, ctx);
        } else if (target instanceof ExprNode) {
            return getObjectInvokeExpr((ExprNode) target, mdName, ctx.params, ctx);
        } else {
            throw Exceptions.unexceptedValue(target);
        }
    } else if (refKey.equals("->")) {
        ExprNode[] invokeArgs = new ExprNode[3];
        ExprNode[] params = new ExprNode[ctx.params.size()];
        if (target instanceof ClassReference) {
            invokeArgs[0] = new ConstExpr(null);
        } else if (target instanceof ExprNode) {
            invokeArgs[0] = ((ExprNode) target);
        }
        invokeArgs[1] = new ConstExpr(mdName);
        for (int i = 0; i < params.length; i++) {
            params[i] = visitExpression(ctx.params.get(i));
        }
        invokeArgs[2] = createInitializedArray(Types.getRootType(), params);
        ClassNode dispatcherAst = getAst("kalang.runtime.dynamic.MethodDispatcher");
        if (dispatcherAst == null) {
            throw Exceptions.unexceptedException("Runtime library is required!");
        }
        return getStaticInvokeExpr(new ClassReference(dispatcherAst), "invokeMethod", invokeArgs, ctx);
    } else if (refKey.equals("*.")) {
        if (!(target instanceof ExprNode)) {
            handleSyntaxError("expression required", ctx.expression);
            return null;
        }
        ExprNode targetExpr = (ExprNode) target;
        Type targetType = targetExpr.getType();
        if (!(targetType instanceof ArrayType)) {
            handleSyntaxError("array required", ctx.expression);
            return null;
        }
        List<Statement> stats = new LinkedList();
        LocalVarNode varArrLen = this.declareTempLocalVar(Types.INT_TYPE);
        LocalVarNode varCounter = this.declareTempLocalVar(Types.INT_TYPE);
        stats.add(new VarDeclStmt(Arrays.asList(varArrLen, varCounter)));
        VarExpr varArrLenExpr = new VarExpr(varArrLen);
        VarExpr varCounterExpr = new VarExpr(varCounter);
        stats.add(new ExprStmt(new AssignExpr(varArrLenExpr, new ArrayLengthExpr(targetExpr))));
        stats.add(new ExprStmt(new AssignExpr(varCounterExpr, new ConstExpr(0))));
        CompareExpr conditionExpr = new CompareExpr(varCounterExpr, varArrLenExpr, CompareExpr.OP_LT);
        ExprNode targetEleExpr = new ElementExpr(targetExpr, varCounterExpr);
        ExprNode invokeExpr = getObjectInvokeExpr(targetEleExpr, mdName, ctx.params, ctx);
        if (invokeExpr == null)
            return null;
        LocalVarNode varRet = this.declareTempLocalVar(Types.getArrayType(invokeExpr.getType()));
        VarExpr varRetExpr = new VarExpr(varRet);
        stats.add(new VarDeclStmt(varRet));
        stats.add(new ExprStmt(new AssignExpr(varRetExpr, new NewArrayExpr(invokeExpr.getType(), varArrLenExpr))));
        BlockStmt loopBody = this.newBlock();
        loopBody.statements.add(new ExprStmt(new AssignExpr(new ElementExpr(varRetExpr, varCounterExpr), invokeExpr)));
        popBlock();
        BlockStmt updateBs = newBlock();
        updateBs.statements.add(new ExprStmt(new AssignExpr(varCounterExpr, new MathExpr(varCounterExpr, new ConstExpr(1), MathExpr.OP_ADD))));
        this.popBlock();
        LoopStmt loopStmt = new LoopStmt(conditionExpr, null, loopBody, updateBs);
        stats.add(loopStmt);
        return new MultiStmtExpr(stats, varRetExpr);
    } else {
        throw Exceptions.unexceptedException(refKey);
    }
}

Example 5 with Statement

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

the class AstBuilder method createInitializedArray.

public ExprNode createInitializedArray(Type type, ExprNode[] exprs) {
    NewArrayExpr ae = new NewArrayExpr(type, new ConstExpr(exprs.length));
    if (exprs.length > 0) {
        Statement[] initStmts = new Statement[exprs.length + 2];
        // TODO create a method for temp var creation
        // TODO localVarNode should add a type parameter
        LocalVarNode local = this.declareTempLocalVar(ae.getType());
        initStmts[0] = new VarDeclStmt(local);
        VarExpr arrVar = new VarExpr(local);
        initStmts[1] = new ExprStmt(new AssignExpr(arrVar, ae));
        for (int i = 0; i < exprs.length; i++) {
            initStmts[i + 2] = new ExprStmt(new AssignExpr(new ElementExpr(arrVar, new ConstExpr(i)), exprs[i]));
        }
        return new MultiStmtExpr(Arrays.asList(initStmts), arrVar);
    } else {
        return ae;
    }
}