source: proto/pablo/src/compiler/lang/pabloS/BuiltinsUtil.java @ 2757

package compiler.lang.pabloS;

import pabloS.ast.*;
import compiler.pabloS.ast.helpers.Accessors;

public class BuiltinsUtil {
    
    public static String BUILTIN_PACKAGE_NAME = "pablo";
        
    public static boolean isAdvance(ASTNode node) {
        if(node == null) {
                return false;
        }
        
        if (!(node instanceof FuncCallNode)) {
            return false;
        }
        
        FuncCallNode fNode = (FuncCallNode)node;
        ASTNode nameNode = Accessors.funcCallIdentifier(fNode);
        ASTNode ArgsListNode = (ASTNode)Accessors.funcCallArgsListNode(fNode); 
   
        // Advance(X)
        if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloName())
                && ArgsListNode.nChildren() == 1) {
            return true;
        }

        // Advance(X,n)
        if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloName())
                && ArgsListNode.nChildren() == 2) {     
                        return true;
        }
        
        return false;        
    }

    public static boolean isBuiltinOperations(ASTNode node) {
        
                for (Builtins builtin : Builtins.values()) {    
                if (isQualifiedName(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloName())) {
                    return true;
                }               
                }
                return false;
    }
     
    
    public static boolean isCarryOne(ASTNode node) {
        
                for (Builtins carryOneOperation : Builtins.carryOneOperations()) {                      
                                
                        ASTNode identifier = Accessors.funcCallIdentifier((FuncCallNode) node);
                        int argCount = Accessors.funcCallArgCount((FuncCallNode)node); 
                        
                        if (isQualifiedName(identifier, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryOneOperation.pabloName()) 
                                && argCount == carryOneOperation.argCount()) {
                    return true;
                }               
                }
                return false;
    }
    
    public static boolean isCarryN(ASTNode node) {
                
                for (Builtins carryNOperation : Builtins.carryNOperations()) {
                        ASTNode identifier = Accessors.funcCallIdentifier((FuncCallNode) node);
                        int argCount = Accessors.funcCallArgCount((FuncCallNode) node); 
                        
                if (isQualifiedName(identifier, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryNOperation.pabloName()) 
                        && argCount == carryNOperation.argCount()) {
                        return true;
                }               
                }
                return false;
    }
    
        
    
    /** Returns true if the node represents a call to the 
     *  given built-in Func.
     *  
     * @param node                  node to be checked
     * @return                      whether the node is a call of the Func
     */
    public static boolean isBuiltInCallNoArgCount(ASTNode node) {
        if(!(node instanceof FuncCallNode)) {
            return false;
        }
        
        FuncCallNode fNode = (FuncCallNode)node;
        ASTNode nameNode = Accessors.funcCallIdentifier(fNode);

        for (Builtins builtin : Builtins.values()) {
            if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloName())) {
                return true;
            }
        }
                
        return false;
    }
    
    /** Returns true if the node represents a call to the 
     *  given built-in Func with the given number of Args.
     *  
     * @param node                  node to be checked
     * @return                      whether the node is a call of the Func with argNumToMatch Args
     */
    public static boolean isBuiltInCall(ASTNode node) {
        
        for (Builtins builtin : Builtins.values()) {    
            if (isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloName(), builtin.argCount())) {
                return true;
            }
        }        

        return false;
    }
    
    /** Returns true if the node represents a call to the 
     *  given Func with the given number of Args.
     *  If node does not have a packageName attached, it is assumed to match the given packageName.
     *  
     * @param node                  node to be checked
     * @param packageName           package name that must be matched.
     * @param FuncName          name of Func to be matched
     * @param numArgs               number of Args to be matched
     * @return                      whether the node is a call of the Func with argNumToMatch Args
     */
    public static boolean isCall(ASTNode node, String packageName, String FuncName, int numArgs) {
        if(!(node instanceof FuncCallNode)) {
            return false;
        }
        
        FuncCallNode fNode = (FuncCallNode)node;
        ASTNode nameNode = Accessors.funcCallIdentifier(fNode);

        boolean nameMatches = isQualifiedName(nameNode, packageName, FuncName);
        boolean numArgsMatches = Accessors.funcCallArgsListNode(fNode).nChildren() == numArgs;
        
        return nameMatches && numArgsMatches;
    }
    
    /** Determines if node represents the name of the Func described by packageName, FuncName.
     *  In particular, if node represents a simple (non-qualified) name, then it is compared with FuncName.
     *  (Essentially, this assumes that the packageName is correct.)
     *  If node represents a compound (qualified) name, then it is compared with 'packageName.FuncName'.
     *  
     * @param node
     * @param packageName
     * @param FuncName
     * @return True if the node matches packageName.FuncName.
     */
    public static boolean isQualifiedName(ASTNode node, String packageName, String FuncName) {
        if(node instanceof IdentifierNode) {            
            return Accessors.name(node) == FuncName;
        }
        else if (node instanceof CompoundIdentifierNode) {
            ASTNode pckage = node.child(0);
            ASTNode member = node.child(1);
            
            return   (Accessors.name(pckage) == packageName) &&
                     (Accessors.name(member) == FuncName);
        }
        return false;
    }
       
}