Пример #1
0
 /// <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));
 }
Пример #2
0
        /// <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());
                }
            }
        }
Пример #3
0
        /// <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);
        }
Пример #4
0
        /// <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);
            }
        }