コード例 #1
0
        public static Argument Evaluate(CompilerState state, SyntaxNode node)
        {
            if (state is null)
            {
                throw new ArgumentNullException(nameof(state));
            }
            if (node is null)
            {
                throw new ArgumentNullException(nameof(node));
            }

            var result = node switch
            {
                TextSyntax text => textInstruction.Evaluate(state, text),
                QuoteSyntax quote => quoteInstruction.Evaluate(state, quote),
                StringLiteralSyntax stringLiteral => stringInstruction.Evaluate(state, stringLiteral),
                ArgumentSyntax argumentSyntax => argumentInstruction.Evaluate(state, argumentSyntax),
                CommandSyntax command => commandInstruction.Evaluate(state, command),
                ObjectSyntax objectSyntax => objectCreationInstruction.Evaluate(state, objectSyntax),
                FieldSyntax fieldSyntax => fieldInstruction.Evaluate(state, fieldSyntax),
                ArraySyntax arraySyntax => arrayInstruction.Evaluate(state, arraySyntax),
                PercentSyntax percentSyntax => percentInstruction.Evaluate(state, percentSyntax),
                ListSyntax list => blockInstruction.Evaluate(state, list),
                CommentSyntax _ => null,
                _ => throw new ArgumentException($"Evaluation of node type {node.GetType().Name} not implemented.", nameof(node)),
            };

            return(new Argument(node, result));
        }
コード例 #2
0
        private static ListSyntax ParseExplicitBlock(ParserContext context)
        {
            var token = context.Tokens.Dequeue();
            var span  = token.Span;
            var list  = new ListSyntax();

            SkipWhitespaceTokens(context);

            if (context.Tokens.Peek().Type == TokenType.CurlyClose)
            {
                context.Tokens.Dequeue();
                list.Span = span;
                return(list);
            }

            while (token.Type != TokenType.None)
            {
                if (token.Type == TokenType.CurlyClose)
                {
                    context.Tokens.Dequeue();
                    break;
                }

                list.Add(ParseBlock(context));
                token = context.Tokens.Peek();
            }

            list.Span = span.WithEnd(token.Span.End);

            return(list);
        }
コード例 #3
0
 private static void CleanText(ListSyntax list)
 {
     if (list.Count > 0 && list[^ 1] is TextSyntax textSyntax)
     {
         textSyntax.Text = textSyntax.Text.TrimEnd();
     }
 }
コード例 #4
0
        public void FailureNullValue()
        {
            var element  = new ListSyntax();
            var argument = new Argument(element, null);

            var success = DynamicDispatch.IsAssignableFrom(loaded, typeof(string), null, argument, out var transformed);

            Assert.False(success);
            Assert.Null(transformed);
        }
コード例 #5
0
        public void SuccessfullArrayString(Type targetType)
        {
            var element  = new ListSyntax();
            var value    = new string[] { "first", "second" };
            var argument = new Argument(element, value);

            var success = DynamicDispatch.IsAssignableFrom(loaded, targetType, null, argument, out var transformed);

            Assert.True(success);
            Assert.IsAssignableFrom(targetType, transformed);
        }
コード例 #6
0
        public void SuccessfullSingleString(Type targetType)
        {
            var element  = new ListSyntax();
            var value    = "stringValue";
            var argument = new Argument(element, value);

            var success = DynamicDispatch.IsAssignableFrom(loaded, targetType, null, argument, out var transformed);

            Assert.True(success);
            Assert.IsAssignableFrom(targetType, transformed);
        }
コード例 #7
0
        private static ListSyntax <ArgumentSyntax> ParseArguments(ParserContext context)
        {
            var token = context.Tokens.Dequeue();
            var span  = token.Span;
            var list  = new ListSyntax <ArgumentSyntax>();

            SkipWhitespaceTokens(context);

            if (context.Tokens.Peek().Type == TokenType.ParenthesesClose)
            {
                context.Tokens.Dequeue();
                list.Span = span;
                return(list);
            }

            while (token.Type != TokenType.None)
            {
                if (token.Type == TokenType.ParenthesesClose)
                {
                    context.Tokens.Dequeue();
                    break;
                }
                else if (token.Type == TokenType.Semicolon)
                {
                    context.Tokens.Dequeue();
                }

                list.Add(ParseArgument(context));
                token = context.Tokens.Peek();
            }

            for (int i = 0; i < list.Count; i++)
            {
                list[i].Position = i;
            }

            list.Span = span.WithEnd(token.Span.End);

            return(list);
        }
コード例 #8
0
        private static ObjectSyntax ParseObject(ParserContext context)
        {
            var token = context.Tokens.Dequeue();
            var span  = token.Span;
            var obj   = new ObjectSyntax();
            var list  = new ListSyntax <FieldSyntax>();

            obj.Fields = list;

            SkipWhitespaceTokens(context);

            if (context.Tokens.Peek().Type == TokenType.CurlyClose)
            {
                context.Tokens.Dequeue();
                list.Span = span;
                return(obj);
            }

            while (token.Type != TokenType.None)
            {
                if (token.Type == TokenType.CurlyClose)
                {
                    context.Tokens.Dequeue();
                    break;
                }

                var field = ParseField(context);
                if (field != null)
                {
                    list.Add(field);
                }
                token = context.Tokens.Peek();
            }

            list.Span = span.WithEnd(token.Span.End);

            return(obj);
        }
コード例 #9
0
        private static ListSyntax ParseBlock(ParserContext context, params TokenType[] stop)
        {
            var        token           = context.Tokens.Peek();
            var        span            = token !.Span;
            var        list            = new ListSyntax();
            bool       continueParsing = true;
            SyntaxNode?outNode         = null;

            while (continueParsing && token.Type != TokenType.None)
            {
                continueParsing = ParseElement(context, stop, out outNode);
                if (outNode != null)
                {
                    list.Add(outNode);
                }
                token = context.Tokens.Peek();
            }

            token     = context.Tokens.Peek();
            list.Span = span.WithEnd(token.Span.End);
            context.Tokens.SkipWhile(e => e.Type == TokenType.Newline);

            return(list);
        }