public override object?Evaluate(CompilerState state, ArgumentSyntax node)
        {
            var value  = (EngineInstruction.Evaluate(state, node.Content).Value as Argument[]) !;
            var result = value.Select(e => e.Value).ToArray();

            return(result);
        }
示例#2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="state"></param>
        /// <param name="arguments"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException"/>
        /// <exception cref="CompilerException"/>
        public override object?Evaluate(CompilerState state, CommandSyntax commandSyntax)
        {
            if (state is null)
            {
                throw new ArgumentNullException(nameof(state));
            }

            if (commandSyntax is null)
            {
                throw new ArgumentNullException(nameof(commandSyntax));
            }

            if (commandSyntax.Name == null)
            {
                throw new CompilerException(commandSyntax, "Received command without a name.");
            }

            var command = state.Commands.Find(commandSyntax.Name.Value, commandSyntax.Arguments);

            if (command == null)
            {
                throw new CompilerException(commandSyntax, $"Could not find command '{commandSyntax.Name.Value}'.");
            }

            var arguments = new List <Argument>();

            foreach (var argSyntax in commandSyntax.Arguments)
            {
                var argResult = EngineInstruction.Evaluate(state, argSyntax);
                arguments.Add(argResult);
            }

            if (commandSyntax.Environment != null)
            {
                var block = EngineInstruction.Evaluate(state, commandSyntax.Environment);
                arguments.Add(block);
            }

            try
            {
                var obj = command.Execution(commandSyntax, state, arguments.ToArray());
                state.Context.Logger.Debug($"Successfully executed command '{command.Name}'.");
                return(obj);
            }
            catch (CompilerException e)
            {
                e.Origin ??= commandSyntax;
                throw;
            }
            catch (Exception ex)
            {
                throw new CompilerException(commandSyntax, ex.Message, ex);
            }
        }
示例#3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="state"></param>
        /// <param name="arguments"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException"/>
        public override object Evaluate(CompilerState state, ListSyntax list)
        {
            if (state is null)
            {
                throw new ArgumentNullException(nameof(state));
            }

            if (list is null)
            {
                throw new ArgumentNullException(nameof(list));
            }

            var results = new List <Argument>();

            // Group continueous leafs into one paragraph
            Paragraph?currentParagraph = null;

            foreach (var element in list.SelectMany(e => EngineInstruction.Evaluate(state, e).Flatten()))
            {
                if (element.Value is Leaf leaf)
                {
                    if (currentParagraph == null)
                    {
                        currentParagraph = new Paragraph();
                        results.Add(new Argument(element.Source, currentParagraph));
                    }

                    currentParagraph.Leaves.Add(leaf);
                }
                else if (element.Value is string str)
                {
                    if (currentParagraph == null)
                    {
                        currentParagraph = new Paragraph();
                        results.Add(new Argument(element.Source, currentParagraph));
                    }

                    currentParagraph.Leaves.Add(new TextLeaf(str));
                }
                else if (element.Value != null)
                {
                    currentParagraph = null;
                    results.Add(element);
                }
            }

            return(results.ToArray());
        }
示例#4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="state"></param>
        /// <param name="arguments"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentException"/>
        /// <exception cref="ArgumentNullException"/>
        public override object?Evaluate(CompilerState state, FieldSyntax field)
        {
            if (field is null)
            {
                throw new ArgumentNullException(nameof(field));
            }

            if (field.Name is null)
            {
                throw new ArgumentException("Field name cannot be empty", nameof(field));
            }

            var fieldArgument = EngineInstruction.Evaluate(state, field.Value);

            return(new ObjectField(field, field.Name.Value, fieldArgument));
        }
示例#5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="state"></param>
        /// <param name="array"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException"/>
        public override object?Evaluate(CompilerState state, ArraySyntax array)
        {
            if (state is null)
            {
                throw new ArgumentNullException(nameof(state));
            }

            if (array is null)
            {
                throw new ArgumentNullException(nameof(array));
            }

            var arguments = new List <Argument>();

            foreach (var arrayElement in array)
            {
                arguments.Add(EngineInstruction.Evaluate(state, arrayElement));
            }

            return(new ObjectArray(array, state, arguments.ToArray()));
        }
示例#6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="state"></param>
        /// <param name="arguments"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException"/>
        public override object?Evaluate(CompilerState state, ObjectSyntax obj)
        {
            if (state is null)
            {
                throw new ArgumentNullException(nameof(state));
            }

            if (obj is null)
            {
                throw new ArgumentNullException(nameof(obj));
            }

            var creator = new ObjectCreator(obj, state);
            var fields  = new List <ObjectField>();

            foreach (var field in obj.Fields)
            {
                fields.Add((EngineInstruction.Evaluate(state, field).Value as ObjectField) !);
            }

            creator.Fields.AddRange(fields);
            return(creator);
        }