Пример #1
0
        private CommandArgumentNode?ParseCommandArgument(CommandNode commandNode)
        {
            if (CurrentToken.Type != TokenType.Argument)
            {
                return(null);
            }

            IArgument?argument = default;

            for (var i = 0; i < commandNode.Command.Arguments.Count; i++)
            {
                if (commandNode.Command.Arguments[i] is {} arg&&
                    !IsFull(arg))
                {
                    argument = arg;
                    break;
                }
            }

            if (argument is null)
            {
                return(null);
            }

            var argumentNode = new CommandArgumentNode(
                CurrentToken,
                argument,
                commandNode);

            IncrementCount(argument);

            Advance();

            return(argumentNode);
        }
Пример #2
0
        private CommandArgumentNode ParseCommandArgument(CommandNode commandNode)
        {
            if (CurrentToken.Type != TokenType.Argument)
            {
                return(null);
            }

            var argument = commandNode.Command
                           .Arguments
                           .FirstOrDefault(a => !IsFull(a));

            if (argument == null)
            {
                return(null);
            }

            var argumentNode = new CommandArgumentNode(
                CurrentToken,
                argument,
                commandNode);

            IncrementCount(argument);

            Advance();

            return(argumentNode);
        }
Пример #3
0
        private void ParseCommandChildren(CommandNode parent)
        {
            while (More())
            {
                if (CurrentToken.Type == TokenType.EndOfArguments)
                {
                    return;
                }

                var child =
                    ParseSubcommand(parent)
                    ?? (SyntaxNode?)ParseOption(parent)
                    ?? ParseCommandArgument(parent);

                if (child is null)
                {
                    UnmatchedTokens.Add(CurrentToken);
                    Advance();
                }
                else
                {
                    parent.AddChildNode(child);
                }
            }
        }
Пример #4
0
        protected override void VisitCommandNode(CommandNode commandNode)
        {
            var commandResult = new CommandResult(
                commandNode.Command,
                commandNode.Token,
                _innermostCommandResult
                );

            _innermostCommandResult !.Children.Add(commandResult);

            _innermostCommandResult = commandResult;
        }
Пример #5
0
        private CommandNode?ParseSubcommand(CommandNode parentNode)
        {
            if (CurrentToken.Type != TokenType.Command)
            {
                return(null);
            }

            if (parentNode.Command.Children.GetByAlias(CurrentToken.Value) is ICommand command)
            {
                var commandNode = new CommandNode(CurrentToken, command, parentNode);

                Advance();

                ParseCommandChildren(commandNode);

                return(commandNode);
            }

            return(null);
        }
Пример #6
0
        private OptionNode?ParseOption(CommandNode parent)
        {
            if (CurrentToken.Type != TokenType.Option)
            {
                return(null);
            }

            OptionNode?optionNode = null;

            if (parent.Command.Children.GetByAlias(CurrentToken.Value) is IOption option)
            {
                optionNode = new OptionNode(CurrentToken, option, parent);

                Advance();

                ParseOptionArguments(optionNode);
            }

            return(optionNode);
        }