private SemanticCheckResult CheckFunctionDeclaration(SemActs semActs, FunctionDeclareExpr exp)
{
// 1. Number of params
var func = exp.Function;
var initialErrorCount = _errors.Count;
if (func.Meta.Arguments.Count > 12)
{
AddErrorCode(ErrorCodes.Func1004, exp);
}
// 2. Too many aliases on function
if (func.Meta.Aliases != null && func.Meta.Aliases.Count > 5)
{
AddError(ErrorCodes.Func1005, exp);
}
// 3. Parameter named arguments?
if (func.Meta.ArgumentsLookup.ContainsKey("arguments"))
{
AddErrorCode(ErrorCodes.Func1003, exp);
}
return(initialErrorCount == _errors.Count
? SemanticCheckResult.Valid
: SemanticCheckResult.ErrorContinue);
}
/// <summary>
/// Parses a function declaration statement.
/// This method is made public to allow other plugins to be used to allow different
/// words to represent "function" e.g. "def" instead of "function"
/// </summary>
/// <param name="token">The tokendata representing the starting token e.g. "function".</param>
/// <param name="expectToken">Whether or not to expect the token in tokenData.
/// If false, advances the token iterator</param>
/// <returns></returns>
public Expr Parse(TokenData token, bool expectToken)
{
var stmt = new FunctionDeclareExpr();
_parser.SetupContext(stmt.Function, token);
if (expectToken)
{
_tokenIt.Expect(token.Token);
}
else
{
_tokenIt.Advance();
}
// Function name.
var name = _tokenIt.ExpectId(true, true);
var aliases = new List <string>();
var nextToken = _tokenIt.NextToken;
List <string> argNames = null;
// Option 1: Wild card
if (nextToken.Token == Tokens.Multiply)
{
stmt.Function.Meta.HasWildCard = true;
nextToken = _tokenIt.Advance();
}
// Option 2: Aliases
else if (nextToken.Token == Tokens.Comma)
{
// Collect all function aliases
while (nextToken.Token == Tokens.Comma)
{
_tokenIt.Advance();
var alias = _tokenIt.ExpectId(true, true);
aliases.Add(alias);
nextToken = _tokenIt.NextToken;
}
if (aliases.Count > 0)
{
stmt.Function.Meta.Aliases = aliases;
}
}
// Get the parameters.
if (nextToken.Token == Tokens.LeftParenthesis)
{
_tokenIt.Expect(Tokens.LeftParenthesis);
argNames = _parser.ParseNames();
_tokenIt.Expect(Tokens.RightParenthesis);
}
stmt.Function.Meta.Init(name, argNames);
// Now parser the function block.
ParseBlock(stmt.Function);
return(stmt);
}
/// <summary>
/// Visits the function call expression tree
/// </summary>
/// <param name="exp"></param>
public object VisitFunctionDeclare(FunctionDeclareExpr exp)
{
_callBackOnNodeStart(exp);
for (var ndx = 0; ndx < exp.Function.Statements.Count; ndx++)
{
var stmt = exp.Function.Statements[ndx];
stmt.Visit(this);
}
_callBackOnNodeEnd(exp);
return(null);
}
/// <summary>
/// Parses a function declaration statement.
/// This method is made public to allow other plugins to be used to allow different
/// words to represent "function" e.g. "def" instead of "function"
/// </summary>
/// <param name="token">The tokendata representing the starting token e.g. "function".</param>
/// <param name="expectToken">Whether or not to expect the token in tokenData.
/// If false, advances the token iterator</param>
/// <returns></returns>
public Expr Parse(TokenData token, bool expectToken)
{
var stmt = new FunctionDeclareExpr();
_parser.SetupContext(stmt.Function, token);
if (expectToken) _tokenIt.Expect(token.Token);
else _tokenIt.Advance();
// Function name.
var name = _tokenIt.ExpectId(true, true);
var aliases = new List<string>();
var nextToken = _tokenIt.NextToken;
List<string> argNames = null;
// Option 1: Wild card
if (nextToken.Token == Tokens.Multiply)
{
stmt.Function.Meta.HasWildCard = true;
nextToken = _tokenIt.Advance();
}
// Option 2: Aliases
else if (nextToken.Token == Tokens.Comma)
{
// Collect all function aliases
while (nextToken.Token == Tokens.Comma)
{
_tokenIt.Advance();
var alias = _tokenIt.ExpectId(true, true);
aliases.Add(alias);
nextToken = _tokenIt.NextToken;
}
if (aliases.Count > 0)
stmt.Function.Meta.Aliases = aliases;
}
// Get the parameters.
if (nextToken.Token == Tokens.LeftParenthesis)
{
_tokenIt.Expect(Tokens.LeftParenthesis);
argNames = _parser.ParseNames();
_tokenIt.Expect(Tokens.RightParenthesis);
}
stmt.Function.Meta.Init(name, argNames);
// Now parser the function block.
ParseBlock(stmt.Function);
return stmt;
}
public Expr OnParseFunctionDeclare()
{
var tokenIt = this._parser.TokenIt;
var initiatorToken = tokenIt.NextToken;
var expr = new FunctionDeclareExpr();
// <codeFunctionDeclare>
var token = tokenIt.NextToken;
var expectToken = true;
expr.Function = new FunctionExpr();
expr.Function.Meta = new FunctionMetaData();
_parser.SetupContext(expr.Function, token);
if (expectToken)
{
tokenIt.Expect(token.Token);
}
else
{
tokenIt.Advance();
}
// Function name.
var name = tokenIt.ExpectId(true, true);
var aliases = new List <string>();
var nextToken = tokenIt.NextToken;
List <string> argNames = null;
// Option 1: Wild card
if (nextToken.Token == Tokens.Multiply)
{
expr.Function.Meta.HasWildCard = true;
nextToken = tokenIt.Advance();
}
// Option 2: Aliases
else if (nextToken.Token == Tokens.Comma)
{
// Collect all function aliases
while (nextToken.Token == Tokens.Comma)
{
tokenIt.Advance();
var alias = tokenIt.ExpectId(true, true);
aliases.Add(alias);
nextToken = tokenIt.NextToken;
}
if (aliases.Count > 0)
{
expr.Function.Meta.Aliases = aliases;
}
}
// Get the parameters.
if (nextToken.Token == Tokens.LeftParenthesis)
{
tokenIt.Expect(Tokens.LeftParenthesis);
argNames = _parser.ParseNames();
tokenIt.Expect(Tokens.RightParenthesis);
}
expr.Function.Meta.Init(name, argNames);
// Now parser the function block.
OnParseFunctionDeclareBlock(expr.Function);
// </codeFunctionDeclare>
this._parser.SetupContext(expr, initiatorToken);
return(expr);
}
/// <summary>
/// Visits the function call expression tree
/// </summary>
/// <param name="exp"></param>
public object VisitFunctionDeclare(FunctionDeclareExpr exp)
{
_callBackOnNodeStart(exp);
for(var ndx = 0; ndx < exp.Function.Statements.Count; ndx++)
{
var stmt = exp.Function.Statements[ndx];
stmt.Visit(this);
}
_callBackOnNodeEnd(exp);
return null;
}
private SemanticCheckResult CheckFunctionDeclaration(SemActs semActs, FunctionDeclareExpr exp)
{
// 1. Number of params
var func = exp.Function;
var initialErrorCount = _errors.Count;
if (func.Meta.Arguments.Count > 12)
AddErrorCode(ErrorCodes.Func1004, exp);
// 2. Too many aliases on function
if (func.Meta.Aliases != null && func.Meta.Aliases.Count > 5)
AddError(ErrorCodes.Func1005, exp);
// 3. Parameter named arguments?
if (func.Meta.ArgumentsLookup.ContainsKey("arguments"))
AddErrorCode(ErrorCodes.Func1003, exp);
return initialErrorCount == _errors.Count
? SemanticCheckResult.Valid
: SemanticCheckResult.ErrorContinue;
}
/// <summary>
/// Execute the continue.
/// </summary>
public object VisitFunctionDeclare(FunctionDeclareExpr expr)
{
return(LObjects.Null);
}
