public TypeNode VisitFunctionCall(FunctionCallExpression funcCallExpNode, List <TypeNode> parameterTypes)
        {
            TypeNode res;

            if (IsLocalReferenceAMatch(funcCallExpNode, parameterTypes))
            {
                funcCallExpNode.GlobalReferences = new List <int>();
                FunctionTypeNode funcDeclType = (FunctionTypeNode)parameterTypes[funcCallExpNode.LocalReference];
                res = funcDeclType.ReturnType;
            }
            else
            {
                List <int> matchingRefs = funcCallExpNode.GlobalReferences;
                CheckMatches(funcCallExpNode.Children, matchingRefs, parameterTypes);
                if (matchingRefs.Count > 1)
                {
                    throw new OverloadException(funcCallExpNode, GetFunctions(matchingRefs));
                }
                else if (matchingRefs.Count == 0)
                {
                    throw new NoMatchingFunctionFoundException(funcCallExpNode);
                }

                funcCallExpNode.LocalReference   = FunctionCallExpression.NO_LOCAL_REF;
                funcCallExpNode.GlobalReferences = matchingRefs;
                res = _functions[matchingRefs.First()].FunctionType.ReturnType;
            }

            return(res);
        }
        private FunctionNode CreateFunctionNode(ASTNode himeDeclNode)
        {
            ASTNode          himeFuncNode = GetHimeFuncNode(himeDeclNode);
            FunctionTypeNode type         = _expressionHelper.CreateFunctionTypeNode(himeFuncNode.Children[_conf.FUNCTIONTYPE_POS]);

            List <string> parameterIdentifiers = GetParameterIdentifiers(himeFuncNode);
            string        typeID     = GetTypeID(himeFuncNode);
            string        functionID = GetFunctionID(himeFuncNode);

            if (typeID != functionID)
            {
                throw new FunctionIdentifierMatchException(functionID, typeID);
            }

            TextPosition position = himeFuncNode.Children[0].Position;

            if (IsConditional(himeDeclNode))
            {
                List <ConditionNode> conditions = new List <ConditionNode>();
                VisitConditions(GetFunctionContent(himeDeclNode),
                                conditions,
                                false);
                return(new FunctionNode(conditions, typeID, parameterIdentifiers, type,
                                        position.Line, position.Column));
            }
            else
            {
                ConditionNode condition = GetInsertedConditionNode(himeDeclNode);
                return(new FunctionNode(typeID, condition, parameterIdentifiers, type,
                                        position.Line, position.Column));
            }
        }
        public void FunctionCallFunction_UsingLocalReference_PassesCorrectFunctionNodeToFunctionFunction()
        {
            IntegerLiteralExpression functionLit = new IntegerLiteralExpression("1.0", 1, 1);
            List <ExpressionNode>    funcParams  = new List <ExpressionNode> {
                functionLit
            };
            FunctionCallExpression funcCallExpr = new FunctionCallExpression("test", funcParams, 1, 1);

            funcCallExpr.LocalReference   = 0;
            funcCallExpr.GlobalReferences = new List <int>();
            IInterpreterGeneric parent = Substitute.For <IInterpreterGeneric>();

            parent.Dispatch(funcParams[0], Arg.Any <List <object> >(), TypeEnum.Function).Returns((Object)1);
            GenericHelper   functionHelper = SetUpHelper(parent);
            List <TypeNode> typeNodes      = new List <TypeNode> {
                new TypeNode(TypeEnum.Function, 1, 1)
            };
            FunctionTypeNode funcTypeNode = new FunctionTypeNode(null, typeNodes, 1, 1);
            FunctionNode     funcNode     = new FunctionNode("", null, null, funcTypeNode, 1, 1);
            AST ast = new AST(new List <FunctionNode> {
                funcNode
            }, null, 1, 1);

            functionHelper.SetASTRoot(ast);
            FunctionNode res = null;

            parent.Function <Function>(Arg.Do <FunctionNode>(x => res = x), Arg.Any <List <object> >());

            functionHelper.FunctionCall <Function>(funcCallExpr, new List <object> {
                new Function(0)
            });

            res.Should().BeEquivalentTo(funcNode);
        }
 public FunctionNode(List <ConditionNode> conditions, string identifier, List <string> parameterIdentifiers,
                     FunctionTypeNode functionType, int line, int letter) : base(line, letter)
 {
     Conditions           = conditions;
     ParameterIdentifiers = parameterIdentifiers;
     FunctionType         = functionType;
     Identifier           = identifier;
 }
        public static FunctionNode GetFunctionNode(string id)
        {
            IntegerLiteralExpression intLitExpr       = new IntegerLiteralExpression(0, 0, 0);
            ConditionNode            conditionNode    = GetConditionNode(intLitExpr);
            FunctionTypeNode         functionTypeNode = GetFunctionTypeNode();
            List <string>            paramIDs         = new List <string>();

            return(new FunctionNode(id, conditionNode, paramIDs, functionTypeNode, 0, 0));
        }
 public FunctionNode(string identifier, ConditionNode condition, List <string> parameterIdentifiers,
                     FunctionTypeNode functionType, int line, int letter) : base(line, letter)
 {
     Conditions = new List <ConditionNode> {
         condition
     };
     ParameterIdentifiers = parameterIdentifiers;
     FunctionType         = functionType;
     Identifier           = identifier;
 }
        public void FunctionCallFunction_f_f(Object[] numbers, TypeEnum[] types)
        {
            List <Object>         expected   = numbers.ToList();
            List <TypeEnum>       exTypes    = types.ToList();
            List <ExpressionNode> funcParams = new List <ExpressionNode>();
            IInterpreterGeneric   parent     = Substitute.For <IInterpreterGeneric>();
            List <TypeNode>       typeNodes  = new List <TypeNode>();

            for (int i = 0; i < expected.Count; i++)
            {
                switch (expected[i])
                {
                case int x:
                    funcParams.Add(new IntegerLiteralExpression(x.ToString(), 1, 1));
                    break;

                case double x:
                    funcParams.Add(new RealLiteralExpression(x.ToString(), 1, 1));
                    break;

                default:
                    throw new Exception("Unexpected shit");
                }
                parent.Dispatch(funcParams[i], Arg.Any <List <object> >(), exTypes[i]).Returns(expected[i]);
                typeNodes.Add(new TypeNode(exTypes[i], 1, 1));
            }



            FunctionCallExpression funcCallExpr = new FunctionCallExpression("test", funcParams, 1, 1);

            funcCallExpr.GlobalReferences = new List <int> {
                0
            };
            funcCallExpr.LocalReference = -1;
            GenericHelper    functionHelper = SetUpHelper(parent);
            FunctionTypeNode funcTypeNode   = new FunctionTypeNode(null, typeNodes, 1, 1);
            FunctionNode     funcNode       = new FunctionNode("", null, null, funcTypeNode, 1, 1);
            AST ast = new AST(new List <FunctionNode> {
                funcNode
            }, null, 1, 1);

            functionHelper.SetASTRoot(ast);
            List <object> res = new List <object>();

            parent.Function <Function>(Arg.Any <FunctionNode>(), Arg.Do <List <object> >(x => res = x));

            functionHelper.FunctionCall <Function>(funcCallExpr, new List <Object>());

            res.Should().BeEquivalentTo(expected);
        }
 private void CheckEdgeFunction(FunctionTypeNode funcTypeNode, string name, GraphExpression parent)
 {
     if (funcTypeNode.Type != TypeEnum.Function)
     {
         throw new UnmatchableTypesException(parent, funcTypeNode.Type, TypeEnum.Function);
     }
     if (funcTypeNode.ParameterTypes.Count != 1)
     {
         throw new Exception($"{name} function must take a single parameter");
     }
     if (funcTypeNode.ParameterTypes[0].Type != TypeEnum.Element)
     {
         throw new UnmatchableTypesException(parent, funcTypeNode.ParameterTypes[0].Type, TypeEnum.Element);
     }
     if (funcTypeNode.ReturnType.Type != TypeEnum.Element)
     {
         throw new UnmatchableTypesException(parent, funcTypeNode.ReturnType.Type, TypeEnum.Element);
     }
 }
        private bool IsLocalReferenceAMatch(FunctionCallExpression funcCallExpNode, List <TypeNode> parameterTypes)
        {
            if (funcCallExpNode.LocalReference == FunctionCallExpression.NO_LOCAL_REF)
            {
                return(false);
            }

            FunctionTypeNode funcDeclType = (FunctionTypeNode)parameterTypes[funcCallExpNode.LocalReference];

            for (int i = 0; i < funcCallExpNode.Children.Count; i++)
            {
                TypeNode child    = _getType(funcCallExpNode.Children[i], parameterTypes);
                TypeNode expected = funcDeclType.ParameterTypes[i];
                if (!AreTypesEqual(child, expected))
                {
                    return(false);
                }
            }
            return(true);
        }
        public TypeNode VisitGraph(GraphExpression node, List <TypeNode> parameterTypes)
        {
            TypeNode         vertexSet = GetType(node.Children[0], parameterTypes);
            TypeNode         edgeSet   = GetType(node.Children[1], parameterTypes);
            FunctionTypeNode src       = (FunctionTypeNode)GetType(node.Children[2], parameterTypes);
            FunctionTypeNode dst       = (FunctionTypeNode)GetType(node.Children[3], parameterTypes);

            if (vertexSet.Type != TypeEnum.Set)
            {
                throw new UnmatchableTypesException(node, vertexSet.Type, TypeEnum.Set);
            }
            if (edgeSet.Type != TypeEnum.Set)
            {
                throw new UnmatchableTypesException(node, edgeSet.Type, TypeEnum.Set);
            }
            CheckEdgeFunction(src, nameof(src), node);
            CheckEdgeFunction(dst, nameof(dst), node);

            return(new TypeNode(TypeEnum.Graph, 0, 0));
        }
        private bool IsFunctionTypesEqual(FunctionTypeNode a, FunctionTypeNode b)
        {
            if (!AreTypesEqual(a.ReturnType, b.ReturnType))
            {
                return(false);
            }
            if (a.ParameterTypes.Count != b.ParameterTypes.Count)
            {
                return(false);
            }

            for (int i = 0; i < a.ParameterTypes.Count; i++)
            {
                if (!AreTypesEqual(a.ParameterTypes[i], b.ParameterTypes[i]))
                {
                    return(false);
                }
            }
            return(true);
        }
        public TypeNode VisitAnonymousFunction(AnonymousFunctionExpression node, List <TypeNode> parameterTypes)
        {
            List <TypeNode> newScope = new List <TypeNode>();

            newScope.AddRange(parameterTypes);
            newScope.AddRange(node.Types);

            TypeNode returnType = _getType(node.ReturnValue, newScope);

            FunctionTypeNode functionType = new FunctionTypeNode(returnType, newScope, 0, 0);

            int           line      = node.LineNumber;
            int           letter    = node.LineNumber;
            ConditionNode condition = new ConditionNode(node.ReturnValue, line, letter);
            FunctionNode  function  = new FunctionNode(functionType.ToString(), condition,
                                                       node.Identifiers, functionType, line, letter);

            node.Reference = _functions.Count;
            _functions.Add(function);
            return(new FunctionTypeNode(returnType, node.Types, 0, 0));
        }
Пример #13
0
        public static FunctionNode GetFunctionNodeWith(List <string> paramIDs, TypeNode returnType, List <TypeNode> paramTypes)
        {
            FunctionTypeNode fType = new FunctionTypeNode(returnType, paramTypes, 0, 0);

            return(new FunctionNode("f", null, paramIDs, fType, 1, 1));
        }
Пример #14
0
 internal static FunctionNode GetFunction(FunctionTypeNode funcType)
 {
     return(new FunctionNode("", null, null, funcType, 0, 0));
 }
        internal static FunctionNode GetFunctionNode(string id, ConditionNode condition)
        {
            FunctionTypeNode functionTypeNode = GetFunctionTypeNode();

            return(new FunctionNode(id, condition, new List <string>(), functionTypeNode, 0, 0));
        }
        public static FunctionNode GetFunctionNode(string id, List <string> parameters, ConditionNode condition)
        {
            FunctionTypeNode functionTypeNode = GetFunctionTypeNode(parameters.Count, TypeEnum.Function);

            return(new FunctionNode(id, condition, parameters, functionTypeNode, 0, 0));
        }
        internal static FunctionNode GetFunctionNode(string id, string elementId, ConditionNode condition)
        {
            FunctionTypeNode functionTypeNode = GetFunctionTypeNode(1, TypeEnum.Element);

            return(new FunctionNode(id, condition, new List <string>(), functionTypeNode, 0, 0));
        }