/// <summary>
/// Ejecuta una sentencia de declaración
/// </summary>
private void ExecuteDeclare(SentenceDeclare sentence)
{
// Ejecuta la sentencia
Context.Actual.VariablesTable.Add(sentence.Name, sentence.Value);
// Debug
AddDebug($"Declare {sentence.Name} = " + ConvertObjectValue(sentence.Value));
}
/// <summary>
/// Ejecuta una sentencia de declaración
/// </summary>
private async Task ExecuteDeclareAsync(SentenceDeclare sentence, CancellationToken cancellationToken)
{
VariableModel variable = new VariableModel(sentence.Variable.Name, ConvertSymbolType(sentence.Variable.Type));
// Si es un tipo conocido, añade la variable al contexto
if (variable.Type == VariableModel.VariableType.Unknown)
{
AddError($"Unknown variable type: {sentence.Variable.Name} - {sentence.Variable.Type}");
}
else
{
// Ejecuta la expresión
if (sentence.Expressions.Count != 0)
{
variable.Value = (await ExecuteExpressionAsync(sentence.Expressions, cancellationToken)).Value;
}
else
{
variable.AssignDefault();
}
// Si no hay errores, añade la variable a la colección
if (!Stopped)
{
// Ejecuta la sentencia
Context.Actual.VariablesTable.Add(variable);
// Debug
AddDebug($"Declare {sentence.Variable.Name} = " + variable.GetStringValue());
}
}
}
/// <summary>
/// Carga una sentencia de declaración de variables
/// </summary>
private SentenceBase LoadSentenceDeclare(MLNode rootML, VariableModel.VariableType type)
{
SentenceDeclare sentence = new SentenceDeclare();
// Asigna las propiedades
sentence.Type = type;
sentence.Name = rootML.Attributes[TagName].Value;
sentence.Value = ConvertStringValue(type, rootML.Attributes[TagValue].Value);
// Devuelve la sentencia
return(sentence);
}
/// <summary>
/// Interpreta la sentencia de declaración
/// </summary>
/// <remarks>
/// declare type name = expression;
/// declare type name;
/// </remarks>
private SentenceDeclare ParseSentenceDeclare()
{
SentenceDeclare sentence = new SentenceDeclare();
TokenSqlBase token = Lexer.Next();
// Obtiene el tipo: type name = expression;
if (token is TokenSqlReservedWord tokenType)
{
// Obtiene el tipo de variable
sentence.Variable.Type = GetVariableType(tokenType);
// Comprueba antes de continuar
if (sentence.Variable.Type == SymbolModel.SymbolType.Unknown)
{
AddError("Declaration type unknown", token);
}
else
{
// Siguiente token: name = expression;
token = Lexer.Next();
// Debería ser una variable
if (token is TokenSqlVariable tokenVariable && !string.IsNullOrWhiteSpace(tokenVariable.ReadToken.Value))
{
// Asigna el nombre de variable
sentence.Variable.Name = tokenVariable.ReadToken.Value;
// Continua con el resto: = expression; o bien ;
token = Lexer.Next();
// Comprueba que sea un igual o un punto y coma
if (token is TokenSqlSeparator tokenSeparator)
{
if (tokenSeparator.Type == TokenSqlSeparator.SeparatorType.Assign)
{
// Lee las expresiones
sentence.Expressions.AddRange(ParseExpression());
// Comprueba que lo siguiente sea un fin de sentencia
CheckEndSentenceToken();
}
else if (tokenSeparator.Type != TokenSqlSeparator.SeparatorType.EndSentence)
{
AddError("Waiting end of sentence (;)", token);
}
}
else
{
AddError("Waiting assign operator (=) or end of command (;)", token);
}
}
else
{
AddError("Waiting variable name", token);
}
}
/// <summary>
/// Transforma una declaración
/// </summary>
private void TransformDeclare(SentenceDeclare sentence)
{
if (sentence.Expressions.Count > 0)
{
string result = sentence.Variable.Name + " = ";
// Añade la variable al contexto
Context.Actual.VariablesTable.Add(sentence.Variable.Name, ConvertSymbolType(sentence.Variable.Type));
// Añade las expresiones
result += TransformExpressions(sentence.Expressions);
// Añade la sentencia
AddSentence(result);
}
}
