source: proto/s2k/trunk/framework/src/toolchain/b2k/lang/builtin/B2KBuiltinsTranslator.java @ 4023

package toolchain.b2k.lang.builtin;

import static toolchain.b2k.lang.paramBuiltin.idisa.IDISABuiltin.*;
import static toolchain.b2k.lang.type.PrimitiveType.BITBLOCK_SIZE;

import java.util.List;
import b2k.ast.*;
import b2k.inputHandler.*;
import b2k.ast.IntegerConstantNode;
import toolchain.b2k.ast.Accessors;
import toolchain.b2k.ast.Generators;
import toolchain.b2k.ast.Mutators;
import toolchain.b2k.lang.builtin.B2KBuiltins;
import toolchain.s2k.transformer.visitors.S2K2B2K.Context;


// BuiltinTranslators translate s2k builtin calls from s2k to b2k. The translation of b2k calls
// uses a C or CPP 'pablo_blk_call' name.
// The enum values follow the Command pattern, with the benefit of the client not having to 
// instantiate the commands.

public enum B2KBuiltinsTranslator {
    
        CARRY_TRANSLATION {     
                public ASTNode translate(B2KBuiltins builtin, s2k.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
            
                    Locator locator = Generators.makeToken(snode.getToken());
                    
            String b2kBlkCallFuncName     = context.getCode(builtin);
            ASTNode b2kBlkFuncCall        = Generators.makeFuncCallNode(locator, b2kBlkCallFuncName, arrayFromList(args));
            ASTNode srliValue             = Generators.makeIntegerConstantNode(locator, BITBLOCK_SIZE - 1);
            
            return Generators.makeIdisaFuncCallNode(locator, BITBLOCK_SRLI, BITBLOCK_SIZE, srliValue, b2kBlkFuncCall);
                }
        },

        ADVANCEN_TRANSLATION {
                public ASTNode translate(B2KBuiltins builtin, s2k.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
                    Locator locator = Generators.makeTextLocation(snode.getLocation());
                        
                    ASTNode formatValue                 = args.remove(1);
                    String value                        = Accessors.lexeme(formatValue);
                    String templateCode                 = context.getCode(builtin);

                    String b2kBlkCallFuncName           = String.format(templateCode, value);          
                    ASTNode b2kBlkFuncCall              = Generators.makeFuncCallNode(locator, b2kBlkCallFuncName, arrayFromList(args));
                    ASTNode srliValue                   = Generators.makeIntegerConstantNode(locator, BITBLOCK_SIZE - 1);
                    
                    return Generators.makeIdisaFuncCallNode(locator, BITBLOCK_SRLI, BITBLOCK_SIZE, srliValue, b2kBlkFuncCall);
                }
        },
        
        SCANTO_FIRST_TRANSLATION {
        public ASTNode translate(B2KBuiltins builtin, s2k.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
            Locator locator = Generators.makeToken(snode.getToken());            
            
            if(context.isFinalBlockMode()) { 
                args.set(0, Generators.makeExprOrNotEofMaskCall(locator, args.get(0)));
            }
            
            return CARRY_TRANSLATION.translate(B2KBuiltins.FLOW_SCAN_TO_FIRST, snode, context, args);
        }
        },
        
        SCANTO_TRANSLATION {
        public ASTNode translate(B2KBuiltins builtin, s2k.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
            Locator locator = Generators.makeToken(snode.getToken());            
            
            args.set(1, translateScanToArgs(locator, context, args.get(1)));
            
            return CARRY_TRANSLATION.translate(B2KBuiltins.FLOW_SCAN_THRU, snode, context, args);
        }
    },

    ADVANCE_THEN_SCANTO_TRANSLATION {
        public ASTNode translate(B2KBuiltins builtin, s2k.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
            Locator locator = Generators.makeToken(snode.getToken());
            
            args.set(1, translateScanToArgs(locator, context, args.get(1)));   
            
            return CARRY_TRANSLATION.translate(B2KBuiltins.FLOW_ADVANCE_THEN_SCAN_THRU, snode, context, args);
        }

    }, 
    
    ASSERT_ZERO_TRANSLATION {
        public ASTNode translate(B2KBuiltins builtin, s2k.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
            
            Locator locator = Generators.makeToken(snode.getToken());
            
            ASTNode errorStream                     = args.get(0);
            ASTNode errorMsg                        = args.get(1);
            
            String assert0CallName                  = context.getBuiltinEncoder().getCode(B2KBuiltins.FLOW_ASSERT_ZERO);

            ASTNode assert0Call                     = Generators.makeFuncCallNode(locator, assert0CallName, errorStream, errorMsg);

            BlockStmtNode blockStmt                 = Generators.makeBlockStmtNode(locator, assert0Call);
            IfStmtNode replacement                  = Generators.makeIfStmtNode(locator, errorStream.deepCopy(), blockStmt);

            Mutators.surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));

            return replacement;
        }
    },
    
    ATEOF_TRANSLATION {
        public ASTNode translate(B2KBuiltins builtin, s2k.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
            Locator locator = Generators.makeToken(snode.getToken());
            
            if(context.isFinalBlockMode()) { 
                
                return Generators.makeExprAndCEofMaskCall(locator, args.get(0));
            } else {
                
                FieldWidthNode fieldWidth = Generators.makeIdisaFieldWidthNode(locator, 1);
                ASTNode value = Generators.makeIntegerConstantNode(locator, 0);
                return Generators.makeIdisaFuncCallNode(locator, SIMD_CONSTANT, fieldWidth, value);       
            }
        } 
    },

    INFILE_TRANSLATION {
                
        public ASTNode translate(B2KBuiltins builtin, s2k.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
            Locator locator = Generators.makeToken(snode.getToken());
            
            if(context.isFinalBlockMode()) {
                return Generators.makeExprAndEofMaskCall(locator, args.get(0));
            } else {
                return args.get(0);
            }
        }
    },

    MASK_TRANSLATION {
        public ASTNode translate(B2KBuiltins builtin, s2k.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
            
            Locator locator = Generators.makeToken(snode.getToken());
            IntegerConstantNode n       = (IntegerConstantNode)args.get(0);
            ASTNode fieldWidth          = Generators.makeIdisaFieldWidthNode(locator, Accessors.intValue(n));
            ASTNode maskValue           = args.get(1);
            return Generators.makeIdisaFuncCallNode(locator, SIMD_CONSTANT, (FieldWidthNode) fieldWidth, maskValue); 
        }
    },
    
    NULL_TRANSLATION {
        @SuppressWarnings("unused")
                public ASTNode translate() {
                throw new RuntimeException("B2K builtin translation not unimplemented.");
        }
    };

    // Interface
    public ASTNode translate(B2KBuiltins builtin, s2k.ast.FuncCallNode node, Context context, List<ASTNode> args) {
        assert false : "'pablo_blk_' S2KBuiltin translate not implemented for S2KBuitin: " + this.name();
        return null;
    }

    // Helpers
    private static ASTNode translateScanToArgs(Locator locator, Context context, ASTNode arg) {

        if(context.isFinalBlockMode()) { 
            return Generators.makeEofMaskAndCExprCall(locator, arg.deepCopy());
        } else {
            return Generators.makeIdisaFuncCallNode(locator, SIMD_NOT, BITBLOCK_SIZE, arg.deepCopy());
        }

    }

    private static ASTNode[] arrayFromList(List<ASTNode> list) {
        return list.toArray(new ASTNode [list.size()]);
    }
    
    
        
    
}