protected virtual void VisitFunctionDefinition(FunctionDefinitionNode node)
{
Visit(node.TypeNameNode);
Visit(node.NameNode);
Visit(node.ParameterNodes);
Visit(node.BodyNodes);
}
protected virtual T VisitFunctionDefinition(FunctionDefinitionNode node)
{
Visit(node.TypeNameNode);
Visit(node.NameNode);
Visit(node.ParameterNodes);
Visit(node.BodyNodes);
return(DefaultResult);
}
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);
}
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);
}
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;
}
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));
}
}
}
}
