private TokenEvaluatorResult EvaluateFunctionDeclaration(string text, string[] splittedText, EvaluatorArgument evaluatorArgument)
{
var identifierArrayPattern = string.Format("^{0}$", IdentifierArrayPattern);
var isAsync = false;
var identifier = splittedText[3];
var arguments = splittedText[4].Split(',');
var i = 0;
if (text.StartsWith("ASYNC FUNCTION ") || text.StartsWith("FONCTION ASYNC "))
{
isAsync = true;
identifier = splittedText[4];
arguments = splittedText[5].Split(',');
}
arguments = arguments.Where(arg => !string.IsNullOrWhiteSpace(arg)).ToArray();
var parameters = new AlgorithmParameterDeclaration[arguments.Length];
while (i < arguments.Length)
{
var argument = arguments[i].Trim(' ');
if (argument.Contains(" "))
{
throw new SyntaxErrorException(evaluatorArgument, "Cannot resolve this symbol.");
}
if (!Regex.IsMatch(argument, identifierArrayPattern))
{
throw new SyntaxErrorException(evaluatorArgument, "Cannot resolve this symbol.");
}
var isArray = argument.EndsWith("[]");
argument = argument.Replace("[]", string.Empty);
parameters[i] = new AlgorithmParameterDeclaration(argument, isArray);
i++;
}
_inMethod = true;
if (identifier.ToLower() == "main")
{
if (isAsync)
{
throw new SyntaxErrorException(evaluatorArgument, "The entry point method cannot be asynchronous.");
}
if (parameters.Length > 0)
{
throw new SyntaxErrorException(evaluatorArgument, "The entry point method cannot take any argument.");
}
return(new TokenEvaluatorResult(SyntaxTreeTokenType.BeginMethod, TokenType.StatementSeparator, new AlgorithmEntryPointMethod()));
}
if (identifier == ClassConstructorName)
{
if (isAsync)
{
throw new SyntaxErrorException(evaluatorArgument, "A model constructor cannot be asynchronous.");
}
return(new TokenEvaluatorResult(SyntaxTreeTokenType.BeginMethod, TokenType.StatementSeparator, new AlgorithmClassConstructorDeclaration(parameters)));
}
return(new TokenEvaluatorResult(SyntaxTreeTokenType.BeginMethod, TokenType.StatementSeparator, new AlgorithmClassMethodDeclaration(identifier, isAsync, parameters)));
}
internal SyntaxErrorException(EvaluatorArgument evaluatorArgument, string message)
: this(evaluatorArgument.DocumentName, evaluatorArgument.LineNumber, evaluatorArgument.LinePosition, message)
{
}
private TokenEvaluatorResult EvaluateVariableDeclaration(string text, string[] splittedText, EvaluatorArgument evaluatorArgument)
{
var variableName = splittedText[2];
var isArray = variableName.EndsWith("[]");
variableName = variableName.Replace("[]", string.Empty);
// TODO : block
if (!_inMethod && _inClass)
{
var propertyDeclaration = new AlgorithmClassPropertyDeclaration(variableName, isArray);
if (isArray)
{
propertyDeclaration.DefaultValue = new AlgorithmPrimitiveExpression(new List <object>());
}
return(new TokenEvaluatorResult(SyntaxTreeTokenType.PropertyDeclaration, TokenType.StatementSeparator, propertyDeclaration));
}
if (_inMethod || _inProgram)
{
var variableDeclaration = new AlgorithmVariableDeclaration(variableName, isArray);
if (isArray)
{
variableDeclaration.DefaultValue = new AlgorithmPrimitiveExpression(new List <object>());
}
return(new TokenEvaluatorResult(SyntaxTreeTokenType.VariableDeclaration, TokenType.StatementSeparator, variableDeclaration));
}
throw new ValidationException();
}
private TokenEvaluatorResult EvaluateAdditionOperator(string text, string[] splittedText, EvaluatorArgument evaluatorArgument)
{
return(null);
}
private TokenEvaluatorResult EvaluateEndBlock(string text, string[] splittedText, EvaluatorArgument evaluatorArgument)
{
var currentToken = SyntaxTreeTokenType.Unknow;
var keyword = splittedText[2];
switch (keyword)
{
case "FUNCTION":
case "FONCTION":
_inMethod = false;
currentToken = SyntaxTreeTokenType.EndMethod;
break;
case "MODEL":
case "MODELE":
_inClass = false;
_currentClassName = string.Empty;
currentToken = SyntaxTreeTokenType.EndClass;
break;
case "PROGRAM":
case "PROGRAMME":
_inProgram = false;
currentToken = SyntaxTreeTokenType.EndProgram;
break;
}
return(new TokenEvaluatorResult(currentToken, TokenType.StatementSeparator));
}
private TokenEvaluatorResult EvaluateStartBlock(string text, string[] splittedText, EvaluatorArgument evaluatorArgument)
{
AlgorithmObject algorithmObject;
SyntaxTreeTokenType currentToken;
var keyword = splittedText[2];
switch (keyword)
{
case "MODEL":
case "MODELE":
_inClass = true;
_currentClassName = splittedText[3];
currentToken = SyntaxTreeTokenType.BeginClass;
algorithmObject = new AlgorithmClassDeclaration(_currentClassName);
break;
case "PROGRAM":
case "PROGRAMME":
_inProgram = true;
currentToken = SyntaxTreeTokenType.BeginProgram;
algorithmObject = new AlgorithmProgram(splittedText[3]);
break;
default:
if (text.StartsWith("ASYNC FUNCTION ") || text.StartsWith("FONCTION ASYNC ") || text.StartsWith("FUNCTION ") || text.StartsWith("FONCTION "))
{
return(EvaluateFunctionDeclaration(text, splittedText, evaluatorArgument));
}
throw new SyntaxErrorException(evaluatorArgument, "Cannot resolve this symbol.");
}
return(new TokenEvaluatorResult(currentToken, TokenType.StatementSeparator, algorithmObject));
}
private TokenEvaluatorResult EvaluateEndBlock(string text, string[] splittedText, EvaluatorArgument evaluatorArgument)
{
return(null);
}
