/// <summary>
/// Build a <see cref="LSLParameterSignature" /> object based off the signature of this parameter declaration node, with the given parameter index.
/// </summary>
/// <param name="parameterNode">The <see cref="ILSLParameterNode"/>.</param>
/// <param name="parameterIndex">The parameter index to use for the created paramter signature.</param>
/// <returns>The created <see cref="LSLParameterSignature" />.</returns>
/// <exception cref="ArgumentNullException"><paramref name="parameterNode"/> is <see langword="null" />.</exception>
public static LSLParameterSignature CreateSignature(this ILSLParameterNode parameterNode, int parameterIndex)
{
if (parameterNode == null)
{
throw new ArgumentNullException("parameterNode");
}
return(new LSLParameterSignature(parameterNode.Type, parameterNode.Name, false, parameterIndex));
}
void ILSLSyntaxWarningListener.ParameterHidesGlobalVariable(LSLSourceCodeRange location,
ILSLEventSignature eventHandlerSignature,
ILSLParameterNode parameter, ILSLVariableDeclarationNode globalVariable)
{
_warningActionQueue.Enqueue(location.StartIndex,
() =>
SyntaxWarningListener.ParameterHidesGlobalVariable(location, eventHandlerSignature, parameter,
globalVariable));
}
/// <summary>
/// A parameter name of a library defined event handler hides the definition of a global variable.
/// </summary>
/// <param name="location">The location in source code of the parameter that hides the global variable.</param>
/// <param name="eventHandlerSignature">The event handler signature to which the parameter definition belongs to.</param>
/// <param name="parameter">The signature of the parameter that hides the global variable.</param>
/// <param name="globalVariable">The variable declaration node of the global variable that was hidden.</param>
public virtual void ParameterHidesGlobalVariable(LSLSourceCodeRange location,
ILSLEventSignature eventHandlerSignature,
ILSLParameterNode parameter, ILSLVariableDeclarationNode globalVariable)
{
OnWarning(location,
string.Format(
"Parameter \"{0}\" of event handler \"{1}\" hides global variable \"{2}\" defined on line {3}.",
parameter.Name, eventHandlerSignature.Name, globalVariable.Name,
MapLineNumber(globalVariable.SourceRange.LineStart)));
}
/// <summary>
/// Construct an <see cref="LSLVariableNode" /> that references a local parameter node.
/// </summary>
/// <param name="declarationNode">A parameter node that declares the parameter variable.</param>
/// <param name="sourceRange">Optional source range for the area the reference exists in.</param>
internal static LSLVariableNode CreateParameterReference(ILSLParameterNode declarationNode, LSLSourceCodeRange sourceRange = null)
{
return(new LSLVariableNode
{
Name = declarationNode.Name,
TypeName = declarationNode.Type.ToLSLTypeName(),
Type = declarationNode.Type,
ExpressionType = LSLExpressionType.ParameterVariable,
IsConstant = false,
SourceRange = sourceRange
});
}
/// <summary>
/// Construct an <see cref="LSLVariableDeclarationNode" /> that represents a parameter.
/// </summary>
/// <returns>The created variable declaration node.</returns>
/// <param name="declarationNode">A parameter node that declares the parameter variable.</param>
/// <exception cref="ArgumentNullException"><paramref name="declarationNode"/> is <c>null</c>.</exception>
public static LSLVariableDeclarationNode CreateParameter(ILSLParameterNode declarationNode)
{
if (declarationNode == null)
{
throw new ArgumentNullException("declarationNode");
}
var n = new LSLVariableDeclarationNode
{
VariableNode = LSLVariableNode.CreateParameterReference(declarationNode),
SourceRange = declarationNode.SourceRange,
SourceRangesAvailable = true
};
n.VariableNode.Parent = n;
return(n);
}
/// <summary>
/// Create an <see cref="LSLParameterNode" /> by cloning from another.
/// </summary>
/// <param name="other">The other node to clone from.</param>
/// <exception cref="ArgumentNullException"><paramref name="other" /> is <c>null</c>.</exception>
private LSLParameterNode(ILSLParameterNode other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
SourceRangesAvailable = other.SourceRangesAvailable;
if (SourceRangesAvailable)
{
SourceRange = other.SourceRange;
SourceRangeName = other.SourceRangeName;
SourceRangeType = other.SourceRangeType;
}
TypeName = other.TypeName;
Type = other.Type;
Name = other.Name;
ParameterIndex = other.ParameterIndex;
HasErrors = other.HasErrors;
}
/// <summary>
/// Visits a parameter definition of either a user defined function or event handler during syntax tree traversal.
/// </summary>
/// <param name="node">The Syntax Tree Node.</param>
/// <seealso cref="LSLValidatorNodeVisitor{T}.VisitParameterDefinitionList">
/// VisitParameterDefinitionList calls this method
/// while visiting its children.
/// </seealso>
/// <returns>An object of type (T) from the visitor implementation of this function.</returns>
public virtual T VisitParameterDefinition(ILSLParameterNode node)
{
return(default(T));
}
void ILSLSyntaxWarningListener.LocalVariableHidesParameter(LSLSourceCodeRange location,
ILSLFunctionSignature functionSignature,
ILSLVariableDeclarationNode localVariable, ILSLParameterNode parameter)
{
_warningActionQueue.Enqueue(location.StartIndex,
() =>
SyntaxWarningListener.LocalVariableHidesParameter(location, functionSignature, localVariable,
parameter));
}
/// <summary>
/// A local variable name inside of a library defined event handler hides the definition of one of the event handlers
/// parameters.
/// </summary>
/// <param name="location">The location in source code of the local variable that hides the event handler parameter.</param>
/// <param name="eventHandlerSignature">The signature of the event handler in which the local variable is defined.</param>
/// <param name="localVariable">The variable declaration node of the local variable that hides the parameter.</param>
/// <param name="parameter">The parameter node of the parameter that was hidden.</param>
public virtual void LocalVariableHidesParameter(LSLSourceCodeRange location,
ILSLEventSignature eventHandlerSignature,
ILSLVariableDeclarationNode localVariable, ILSLParameterNode parameter)
{
OnWarning(location,
string.Format("Local variable \"{0}\" in event handler \"{1}\" hides parameter \"{2}\".",
localVariable.Name, eventHandlerSignature.Name, parameter.Name));
}
