/// <summary>
/// Construct an <see cref="LSLEventHandlerNode" /> with the given parameter list and code body.
/// </summary>
/// <param name="name">The event handler name.</param>
/// <param name="parameterList">The parameter list.</param>
/// <param name="code">The code body.</param>
/// <exception cref="ArgumentNullException">
/// if <paramref name="name" /> or <paramref name="parameterList" /> or
/// <paramref name="code" /> is <c>null</c>.
/// </exception>
/// <exception cref="LSLInvalidSymbolNameException"><paramref name="name" /> contained characters not allowed in an LSL ID token.</exception>
public LSLEventHandlerNode(string name, LSLParameterListNode parameterList, LSLCodeScopeNode code)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (parameterList == null)
{
throw new ArgumentNullException("parameterList");
}
if (code == null)
{
throw new ArgumentNullException("code");
}
if (!LSLTokenTools.IDRegexAnchored.IsMatch(name))
{
throw new LSLInvalidSymbolNameException("name provided contained characters not allowed in an LSL ID token.");
}
ParameterList = parameterList;
ParameterList.Parent = this;
Name = name;
Code = code;
Code.Parent = this;
Code.CodeScopeType = LSLCodeScopeType.EventHandler;
}
/// <exception cref="ArgumentNullException">
/// <paramref name="parameterList" /> or <paramref name="code" /> is
/// <c>null</c>.
/// </exception>
internal LSLEventHandlerNode(LSLParser.EventHandlerContext context, LSLParameterListNode parameterList,
LSLCodeScopeNode code)
{
if (parameterList == null)
{
throw new ArgumentNullException("parameterList");
}
if (code == null)
{
throw new ArgumentNullException("code");
}
Name = context.handler_name.Text;
Code = code;
Code.Parent = this;
Code.CodeScopeType = LSLCodeScopeType.EventHandler;
ParameterList = parameterList;
ParameterList.Parent = this;
SourceRange = new LSLSourceCodeRange(context);
SourceRangeName = new LSLSourceCodeRange(context.handler_name);
SourceRangesAvailable = true;
}
public override bool VisitFunctionDeclaration(LSLParser.FunctionDeclarationContext context)
{
if (context == null || Utility.AnyNull(context.function_name, context.code))
{
throw LSLCodeValidatorInternalException.VisitContextInvalidState("VisitFunctionDeclaration", true);
}
if (_validatorStrategies.LibraryDataProvider.LibraryFunctionExist(context.function_name.Text))
{
GenSyntaxError().RedefinedStandardLibraryFunction(
new LSLSourceCodeRange(context.function_name), context.function_name.Text,
_validatorStrategies.LibraryDataProvider.GetLibraryFunctionSignatures(
context.function_name.Text));
return(false);
}
if (_scopingManager.FunctionIsPreDefined(context.function_name.Text))
{
GenSyntaxError().RedefinedFunction(
new LSLSourceCodeRange(context.function_name),
_scopingManager.ResolveFunctionPreDefine(context.function_name.Text));
return(false);
}
var parameterListNode = LSLParameterListNode.BuildFromParserContext(
context.parameters,
LSLParameterListType.FunctionParameters,
_validatorStrategies);
if (parameterListNode.HasErrors)
{
return(false);
}
var returnType = LSLType.Void;
if (context.return_type != null)
{
returnType =
LSLTypeTools.FromLSLTypeName(context.return_type.Text);
}
var func = new LSLPreDefinedFunctionSignature(returnType,
context.function_name.Text,
parameterListNode);
_scopingManager.PreDefineFunction(func);
base.VisitFunctionDeclaration(context);
return(true);
}
/// <summary>
/// Construct an <see cref="LSLPreDefinedFunctionSignature" /> from an <see cref="LSLType" /> representing the return
/// type, a function name and an <see cref="LSLParameterListNode" />
/// from an LSL Syntax tree.
/// </summary>
/// <param name="returnType">The return type of the function signature.</param>
/// <param name="name">The name of the function.</param>
/// <param name="parameters">
/// The <see cref="LSLParameterListNode" /> from an LSL syntax tree that represents the function
/// signatures parameters.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="parameters"/> is <see langword="null" />.</exception>
/// <exception cref="LSLInvalidSymbolNameException">
/// Thrown if the function name does not follow LSL symbol naming conventions.
/// </exception>
public LSLPreDefinedFunctionSignature(LSLType returnType, string name, LSLParameterListNode parameters)
: base(returnType, name)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
foreach (var param in parameters)
{
AddParameter(param.CreateSignature());
}
ParameterListNode = parameters;
}
/// <exception cref="ArgumentNullException">
/// <paramref name="parameterList" /> or <paramref name="code" />
/// is <c>null</c>.
/// </exception>
internal LSLFunctionDeclarationNode(LSLParser.FunctionDeclarationContext context,
LSLParameterListNode parameterList, LSLCodeScopeNode code)
{
if (parameterList == null)
{
throw new ArgumentNullException("parameterList");
}
if (code == null)
{
throw new ArgumentNullException("code");
}
if (context.return_type != null)
{
ReturnTypeName = context.return_type.Text;
ReturnType = LSLTypeTools.FromLSLTypeName(ReturnTypeName);
SourceRangeReturnType = new LSLSourceCodeRange(context.return_type);
}
else
{
ReturnTypeName = "";
ReturnType = LSLType.Void;
}
Name = context.function_name.Text;
ParameterList = parameterList;
ParameterList.Parent = this;
Code = code;
Code.Parent = this;
Code.CodeScopeType = LSLCodeScopeType.Function;
SourceRange = new LSLSourceCodeRange(context);
SourceRangeName = new LSLSourceCodeRange(context.function_name);
SourceRangesAvailable = true;
}
/// <summary>
/// Create an <see cref="LSLParameterListNode" /> 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 LSLParameterListNode(LSLParameterListNode other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
SourceRangesAvailable = other.SourceRangesAvailable;
if (SourceRangesAvailable)
{
SourceRange = other.SourceRange;
_sourceRangeCommaList = other.SourceRangeCommaList.ToGenericArray();
}
foreach (var param in other._parameters.Values)
{
Add(param.Clone());
}
HasErrors = other.HasErrors;
}
/// <summary>
/// Construct an <see cref="LSLFunctionDeclarationNode" /> with the given return type, parameter list, and code body.
/// </summary>
/// <param name="returnType">The return type of the function.</param>
/// <param name="functionName">The name of the function.</param>
/// <param name="parameterList">The parameter list node representing the list of parameter definitions for the function.</param>
/// <param name="code">The code scope that makes up the function's code body.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="functionName" /> or <paramref name="parameterList" /> or <paramref name="code" /> is <c>null</c>.
/// </exception>
/// <exception cref="LSLInvalidSymbolNameException">
/// if <paramref name="functionName" /> contains invalid characters for an LSL ID
/// token.
/// </exception>
public LSLFunctionDeclarationNode(LSLType returnType, string functionName,
LSLParameterListNode parameterList, LSLCodeScopeNode code)
{
if (parameterList == null)
{
throw new ArgumentNullException("parameterList");
}
if (code == null)
{
throw new ArgumentNullException("code");
}
if (functionName == null)
{
throw new ArgumentNullException("functionName");
}
if (!LSLTokenTools.IDRegexAnchored.IsMatch(functionName))
{
throw new LSLInvalidSymbolNameException(
"functionName provided contained characters not allowed in an LSL ID token.");
}
Name = functionName;
ReturnTypeName = returnType == LSLType.Void ? "" : LSLTypeTools.ToLSLTypeName(returnType);
ReturnType = returnType;
ParameterList = parameterList;
ParameterList.Parent = this;
Code = code;
Code.Parent = this;
Code.CodeScopeType = LSLCodeScopeType.Function;
}
/// <summary>
/// Builds a parameter list node directly from a parser context, checking for duplicates and reporting
/// duplicate parameter errors via a validator strategies object. <see cref="ILSLCodeValidatorStrategies" />.
/// </summary>
/// <param name="context">The context to build from</param>
/// <param name="validatorStrategies">The validator strategies object to use for reporting errors or warnings</param>
/// <param name="parameterListType">The parameter list type.</param>
/// <returns>the created parameter list node</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="context" /> or <paramref name="validatorStrategies" /> is
/// <c>null</c>.
/// </exception>
internal static LSLParameterListNode BuildFromParserContext(LSLParser.OptionalParameterListContext context,
LSLParameterListType parameterListType, ILSLCodeValidatorStrategies validatorStrategies)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (validatorStrategies == null)
{
throw new ArgumentNullException("validatorStrategies");
}
var result = new LSLParameterListNode(context, parameterListType);
var parameterList = context.parameterList();
if (parameterList == null)
{
return(result);
}
var parameterNames = new HashSet <string>();
var parameterIndex = 0;
foreach (var comma in parameterList.children)
{
//'comma' for some reason will be an internal object
//that cannot be accessed via cast when a COMMA token is encountered.
//
//However, Payload contains a CommonToken instance, which implements IToken.
var token = comma.Payload as IToken;
//when a parameter def is found, 'comma' will be the grammar defined
//LSLParser.ParameterDefinitionContext type.
var parameter = comma as LSLParser.ParameterDefinitionContext;
if (token != null)
{
result._sourceRangeCommaList.Add(new LSLSourceCodeRange(token));
}
else if (parameter != null)
{
if (parameterNames.Contains(parameter.ID().GetText()))
{
var paramLocation = new LSLSourceCodeRange(parameter);
validatorStrategies.SyntaxErrorListener.ParameterNameRedefined(
paramLocation,
parameterListType,
LSLTypeTools.FromLSLTypeName(parameter.TYPE().GetText()),
parameter.ID().GetText());
result.HasErrors = true;
result._parameters.Clear();
return(result);
}
parameterNames.Add(parameter.ID().GetText());
var addition = new LSLParameterNode(parameter)
{
ParameterIndex = parameterIndex
};
result.Add(addition);
parameterIndex++;
}
}
parameterNames.Clear();
return(result);
}
/// <summary>
/// Construct an <see cref="LSLParsedEventHandlerSignature" /> from an event handler name and a
/// <see cref="LSLParameterListNode" /> from
/// an LSL Syntax tree.
/// </summary>
/// <param name="name">The name of the event handler.</param>
/// <param name="parameters">
/// The <see cref="LSLParameterListNode" /> from the syntax tree that represents the event
/// handlers parsed parameters.
/// </param>
public LSLParsedEventHandlerSignature(string name, LSLParameterListNode parameters) :
base(name, parameters.Parameters.Select(x => new LSLParameterSignature(x.Type, x.Name, false)))
{
//TODO validate parameters
ParameterListNode = parameters;
}
