source: proto/s2k/trunk/framework/src/toolchain/s2k/ast/Generators.java @ 3775

/*
 * 
 * Static factories for various node types.
 * 
 * Add factories as needed.
 * 
 * @author <ksherdy at sfu dot ca>
 */

package toolchain.s2k.ast;

import s2k.ast.*;

import s2k.inputHandler.Locator;
import s2k.lexicalAnalyzer.*;
import s2k.tokens.*;
import toolchain.s2k.lang.*;

public class Generators {

        // TS: should change grammar and conventions so that every FuncDefNode has a ParameterListNode child
        //     but the PLN child has no children if there are no args.  This would eliminate the conditional
        //     in this method, and probably make things easier in other methods, too.
        public static void appendParameter(FilterDefNode funcDefNode, FilterParameterNode parameterNode) {
                FilterParameterListNode parameterListNode = null;
                parameterListNode = Accessors.parameterListNode(funcDefNode);
                parameterListNode.appendChild(parameterNode);
        }
        
        public static VarDeclNode makeVarDeclNode(Locator locator, ASTNode type, ASTNode lhs) {
            Token assignToken = Generators.makeLextantToken(locator, Lextant.ASSIGN);
            VarDeclNode localVarDecl = new VarDeclNode(assignToken);
            localVarDecl.appendChild(type);
            localVarDecl.appendChild(lhs);
            return localVarDecl;
        }
        
        public static VarDeclNode makeVarDeclNode(Locator locator, ASTNode type, ASTNode lhs, ASTNode rhs) {            
            VarDeclNode localVarDecl = makeVarDeclNode(locator,type,lhs);
                localVarDecl.appendChild(rhs);
                return localVarDecl;
        }
        
        public static AssignNode makeAssignNode(Locator locator, ASTNode lhs, ASTNode rhs) {
                Token assignToken = Generators.makeLextantToken(locator, Lextant.ASSIGN);
                AssignNode assign = new AssignNode(assignToken);
                assign.appendChild(lhs);
                assign.appendChild(rhs);
                return assign;
        }
        
    ///////////////////////////////////////////////////////////////////
    // Function call variants
        public static FuncCallNode makeFuncCallNode(Locator locator, String identifier) {
                IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);     
                return Generators.makeFuncCallNode(locator, identifierNode);
        }
                
        public static FuncCallNode makeFuncCallNode(Locator locator, String identifier, ASTNode ...args) {
                FuncCallNode node = Generators.makeFuncCallNode(locator, identifier);
                Generators.addFuncCallArgs(node, args);
                return node;
        }       
        
        public static FuncCallNode makeFuncCallNode(Locator locator, String pckage, String name) {
                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
                return Generators.makeFuncCallNode(locator, compoundIdentifierNode);
        }
        
        public static FuncCallNode makeFuncCallNode(Locator locator, String pckage, String name, ASTNode ...args) {
                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
                FuncCallNode node = Generators.makeFuncCallNode(locator, compoundIdentifierNode);
                Generators.addFuncCallArgs(node, args);
                return node;
        }       
        
        private static FuncCallNode makeFuncCallNode(Locator locator, ASTNode identifier) {
                assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));

                LextantToken token = Generators.makeLextantToken(locator, Lextant.LROUND);
                FuncCallNode FuncCallNode = new FuncCallNode(token);
                FuncCallNode.appendChild(identifier);
                FuncCallNode.appendChild(new FuncCallArgListNode(token));               

                return FuncCallNode;
        }       
                
        private static void addFuncCallArgs(FuncCallNode node, ASTNode ... args) {
            for(ASTNode child: args) {
                Accessors.argsListNode(node).appendChild(child.deepCopy());
            }
            Accessors.argsListNode(node).setToken(args[0].getToken());
        }
        
        public static CompoundIdentifierNode makeCompoundIdentifierNode(Locator locator, String pckage, String name) {
                return makeCompoundIdentifierNode(locator, new String [] {pckage, name});
        }
        
        /** Makes a new CompoundIdentifierNode with an array of identifier strings and and the TextLocation taken from locator.
         * Currently, no special consideration with only one identifier in the array. 
         * (Maybe we can return a IdentifierNode directly in later versions.)
         * @param locator               a token containing the TextLocation for this new node.
         * @param identifiers           all identifiers
         * @return      the new CompoundIdentifierNode
         */
        public static CompoundIdentifierNode makeCompoundIdentifierNode(Locator locator, String ... identifiers) {
                Token dotToken = Generators.makeLextantToken(locator, Lextant.DOT);
                CompoundIdentifierNode CompoundIdentifierNode = new CompoundIdentifierNode(dotToken);
                for (String identifier : identifiers) {
                        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
                        CompoundIdentifierNode.appendChild(identifierNode);
                }
                return CompoundIdentifierNode;
        }

        /** Makes a new IdentifierNode with a identifier string and the TextLocation taken from locator.
         * @param locator               a token containing the TextLocation for this new node.
         * @param identifier
         * @return      the new IdentifierNode
         */
        public static IdentifierNode makeIdentifierNode(Locator locator, String identifier) {
                IdentifierToken newToken = Generators.makeIdentifierToken(locator, identifier);
                return new IdentifierNode(newToken);
        }
        
        /** Makes a new LextantToken with the given lextant and location taken from the given locator.
         * @param locator
         * @param lextant
         * @return the new LextantToken
         */
        public static LextantToken makeLextantToken(Locator locator, Lextant lextant) {
                return LextantToken.make(locator.getLocation(), lextant.getPrimaryLexeme(), lextant);
        }

        /** Makes a new StringConstantToken with the given string and location taken from the given locator.
         * @param locator
         * @param string
         * @return the new StringConstantToken
         */
        public static StringConstantToken makeStringConstantToken(Locator locator, String string) {
                return StringConstantToken.make(LexicalType.STRING, locator.getLocation(), string);
        }

        /** Makes a new IdentifierToken with the given identifier and location taken from the given locator.
         * @param locator
         * @param identifier
         * @return the new IdentifierToken
         */
        public static IdentifierToken makeIdentifierToken(Locator locator, String identifier) {
                return IdentifierToken.make(LexicalType.IDENTIFIER, locator.getLocation(), identifier);
        }

        /** Makes a new StringConstantNode with the given string and the TextLocation taken from locator.
         * @param locator                       a locator containing the TextLocation for this new node.
         * @param string                        string value/lexeme of new node.
         * @return      the new StringConstantNode
         */
        public static StringConstantNode makeStringConstantNode(Locator locator, String string) {
                StringConstantToken newToken = makeStringConstantToken(locator, string);
                return new StringConstantNode(newToken);
        }

        /** Makes a new IntegerConstantNode with a value of n and the TextLocation taken from locator.
         * @param locator               a token containing the TextLocation for this new node.
         * @param n                     integer value of new node.
         * @return      the new IntegerConstantNode
         */
        public static IntegerConstantNode makeIntegerConstantNode(Locator locator, int n) {
                Token newToken = IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
                IntegerConstantNode integerConstantNode = new IntegerConstantNode(newToken);
                integerConstantNode.setValue(n);
            return integerConstantNode;
        }
        
        public static IntConstantToken makeIntegerConstantToken(Locator locator,  int n) {
                return (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
        }       
        
        public static StreamTypeNode makeStreamType(Locator locator) {
                Token streamToken = Generators.makeLextantToken(locator, Lextant.STREAM);
                return new StreamTypeNode(streamToken);
        }
        
        public static BinaryOperatorNode makeBinaryOperatorNode(ASTNode lhs, ASTNode rhs, Token token) {
                BinaryOperatorNode node = new BinaryOperatorNode(token);
                node.appendChild(lhs.deepCopy());
                node.appendChild(rhs.deepCopy());
                return node;
        }       
        
        public static BlockStmtNode makeBlockStmtNode(Locator locator, ASTNode ...children) {
                LextantToken token = Generators.makeLextantToken(locator, Lextant.LCURLY);
                
                BlockStmtNode result = new BlockStmtNode(token);
                for(ASTNode child: children) {
                        result.appendChild(child);
                }
                return result;
        }

        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode expression, BlockStmtNode ifBlockStmt, BlockStmtNode elseBlockStmt) {
                IfStmtNode ifStmtNode = makeIfStmtNode(locator, expression, ifBlockStmt);
                ifStmtNode.appendChild(elseBlockStmt);
                return ifStmtNode;
        }       
        
        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode expression, BlockStmtNode blockStmt) {
                LextantToken token = Generators.makeLextantToken(locator, Lextant.LCURLY);
                IfStmtNode ifStmtNode = new IfStmtNode(token);
                ifStmtNode.appendChild(expression);
                ifStmtNode.appendChild((ASTNode)blockStmt);
                return ifStmtNode;
        }

    ///////////////////////////////////////////////////////////////////
    // Mask calls
        public static FuncCallNode makeMaskFuncCall(Locator locator, int fieldWidth, int value) {
                IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(locator, value);
                IntegerConstantNode fieldWidthNode =    Generators.makeIntegerConstantNode(locator, fieldWidth);

                FuncCallNode mask = Generators.makeFuncCallNode(locator, BuiltinCallUtil.BUILTIN_PACKAGE_NAME, 
                                S2KBuiltin.MASK.name(), 
                                arguments(fieldWidthNode, zeroConstantNode));
                return mask;
        }

    ///////////////////////////////////////////////////////////////////
    // Helpers
        public static ASTNode[] arguments(ASTNode...astNodes) {
            return astNodes;
        }
        
        public static String capitalize(String str) {
                return str.substring(0, 1).toUpperCase() + str.substring(1);
        }
        
        public static String unCapitalize(String str) {
                return str.substring(0, 1).toLowerCase() + str.substring(1);
        }

}