protected virtual void VisitFunctionDefinition(FunctionDefinitionNode node)
 {
     Visit(node.TypeNameNode);
     Visit(node.NameNode);
     Visit(node.ParameterNodes);
     Visit(node.BodyNodes);
 }
Example #2
0
 protected virtual T VisitFunctionDefinition(FunctionDefinitionNode node)
 {
     Visit(node.TypeNameNode);
     Visit(node.NameNode);
     Visit(node.ParameterNodes);
     Visit(node.BodyNodes);
     return(DefaultResult);
 }
Example #3
0
        protected override void VisitFunctionDefinition(FunctionDefinitionNode node)
        {
            _initializedLocalsPaths = new HashSet <string>();

            _currentBlockSymbol = (BlockSymbol)node.Symbol;
            base.VisitFunctionDefinition(node);
            _currentBlockSymbol = null;
        }
        protected override void VisitFunctionDefinition(FunctionDefinitionNode node)
        {
            if (node.Symbol is FunctionSymbol functionSymbol)
            {
                functionSymbol.ParametersCount = node.ParameterNodes.Count;
            }


            CheckStatementsForSingleExpressionHack(node.BodyNodes);
            base.VisitFunctionDefinition(node);
        }
Example #5
0
        protected override void VisitFunctionDefinition(FunctionDefinitionNode functionDefinitionNode)
        {
            string functionName   = functionDefinitionNode.NameNode.Value;
            string returnTypeName = functionDefinitionNode.TypeNameCapitalized;
            bool   isExternal     = functionDefinitionNode.IsExternal;

            FunctionSymbol functionSymbol = new FunctionSymbol(returnTypeName, functionName, isExternal, functionDefinitionNode);

            AddSymbol(functionSymbol);
            Visit(functionDefinitionNode.ParameterNodes);
            Visit(functionDefinitionNode.BodyNodes);
        }
Example #6
0
        protected override void VisitReturnStatement(ReturnStatementNode node)
        {
            ASTNode parentBlockNode = node.GetFirstSignificantAncestorNode();
            FunctionDefinitionNode functionDefinitionNode = (FunctionDefinitionNode)parentBlockNode;
            SymbolTypePair         functionType           = GetSymbolTypePairFromSymbol(functionDefinitionNode.Symbol);


            /*
             * if (functionDefinitionNode.Symbol.BuiltinType == SymbolType.Float)
             * {
             *  _isInsideFloatExpression = true;
             * }
             */

            _currentExpressionTypes.Push(functionType);
            base.VisitReturnStatement(node);
            _currentExpressionTypes.Pop();

            //_isInsideFloatExpression = false;
        }
Example #7
0
        public void Check(List <DeclarationNode> declarationNodes)
        {
            foreach (DeclarationNode declarationNode in declarationNodes)
            {
                // Ignore attributes of a class
                if (declarationNode is VarDeclarationNode && declarationNode.ParentNode is ClassDefinitionNode)
                {
                    continue;
                }

                if (declarationNode.Usages.Count == 0)
                {
                    // Ignore symbols used by engine
                    if (_engineUsedSymbols.Contains(declarationNode.NameNode.Value.ToUpper()))
                    {
                        continue;
                    }

                    // Ignore unused parameters of functions used by engine
                    if (declarationNode is ParameterDeclarationNode parameterDeclarationNode)
                    {
                        FunctionDefinitionNode functionDefinitionNode =
                            (FunctionDefinitionNode)parameterDeclarationNode.ParentNode;

                        if (functionDefinitionNode.IsExternal)
                        {
                            continue;
                        }

                        string parentNameUpper = functionDefinitionNode.NameNode.Value.ToUpper();
                        if (_engineUsedSymbols.Contains(parentNameUpper))
                        {
                            continue;
                        }

                        if (parentNameUpper.StartsWith("SPELL_CAST_"))
                        {
                            continue;
                        }
                    }

                    if (declarationNode is FunctionDefinitionNode funcDefinitionNode)
                    {
                        // External functions shouldn't be required to be used
                        if (funcDefinitionNode.IsExternal)
                        {
                            continue;
                        }

                        // Functions named INIT_<ZEN_NAME> and STARTUP_<ZEN_NAME> are used by the engine
                        string nameUpper = funcDefinitionNode.NameNode.Value.ToUpper();
                        if (nameUpper.StartsWith("INIT_") || nameUpper.StartsWith("STARTUP_"))
                        {
                            continue;
                        }

                        // Functions named <NAME>_LOOP and <NAME>_END are used by the engine
                        // if there is function <NAME> that is registered state.
                        Regex stateRegex = new Regex("^([a-zA-Z_][a-zA-Z0-9_]*)_(LOOP|END)$");
                        Match match      = stateRegex.Match(nameUpper);
                        if (match.Success && _symbolTable.ContainsKey(match.Groups[0].Value))
                        {
                            continue;
                        }

                        // Detecting usages of routine functions is very hard and in some cases next to impossible
                        // or even impossible, since they are referenced by their middle part (between RTN_ and _<NUM>) by string
                        Regex regex = new Regex("^RTN_[_A-Z0-9]+_[0-9]+$");
                        if (regex.IsMatch(nameUpper))
                        {
                            continue;
                        }

                        if (_scriptFuncs.Contains(nameUpper))
                        {
                            continue;
                        }

                        if (_conditionFuncs.Contains(nameUpper))
                        {
                            continue;
                        }

                        if (nameUpper.EndsWith("_S1") && _onStateFuncs.Contains(nameUpper))
                        {
                            continue;
                        }

                        if (nameUpper.StartsWith("SPELL_CAST_"))
                        {
                            continue;
                        }
                    }

                    if (declarationNode is InstanceDefinitionNode)
                    {
                        // We can just ignore all instances, since almost always
                        // they can be used even without explicit reference in code
                        continue;
                    }

                    // Some constants are used inside Zen in "focusName" attribute
                    if (declarationNode is ConstDefinitionNode constDefinitionNode)
                    {
                        if (_focusNames.Contains(constDefinitionNode.NameNode.Value.ToUpper()))
                        {
                            continue;
                        }
                    }

                    declarationNode.NameNode.Annotations.Add(new UnusedSymbolWarning());
                    continue;
                }
            }


            foreach (DeclarationNode declarationNode in declarationNodes)
            {
                string declaredName = declarationNode.NameNode.Value;

                foreach (ASTNode node in declarationNode.Usages)
                {
                    string usedName;

                    switch (node)
                    {
                    case ReferenceNode referenceNode:
                        usedName = referenceNode.Name;
                        break;

                    case AttributeNode attributeNode:
                        usedName = attributeNode.Name;
                        break;

                    case NameNode nameNode:
                        usedName = nameNode.Value;
                        break;

                    default:
                        throw new Exception();
                    }

                    if (usedName != declaredName)
                    {
                        node.Annotations.Add(new NamesNotMatchingCaseWiseWarning(declarationNode.NameNode.Location,
                                                                                 declaredName, usedName));
                    }
                }
            }
        }