예제 #1
0
            public ParseResult Parse(StringEnumerator argumentEnumerator, IDictionary map, object options)
            {
                string[] parts = argumentEnumerator.Current.Substring(2).Split(new char[] { '=' }, 2);

                OptionInfo option = (OptionInfo)map[parts[0]];

                if (option == null)
                {
                    return(ParseResult.Failure);
                }

                option.IsDefined = true;

                if (!option.IsBoolean)
                {
                    if (parts.Length == 1 && !argumentEnumerator.IsLast && !IsInputValue(argumentEnumerator.Next))
                    {
                        return(ParseResult.Failure);
                    }

                    if (parts.Length == 2)
                    {
                        if (option.SetValue(parts[1], options))
                        {
                            return(ParseResult.Success);
                        }
                        else
                        {
                            return(ParseResult.Failure);
                        }
                    }
                    else
                    {
                        if (option.SetValue(argumentEnumerator.Next, options))
                        {
                            return(ParseResult.Success | ParseResult.MoveOnNextElement);
                        }
                        else
                        {
                            return(ParseResult.Failure);
                        }
                    }
                }
                else
                {
                    if (parts.Length == 2)
                    {
                        return(ParseResult.Failure);
                    }
                    if (option.SetValue(true, options))
                    {
                        return(ParseResult.Success);
                    }
                    else
                    {
                        return(ParseResult.Failure);
                    }
                }
            }
예제 #2
0
        private bool ParseArgumentList(string[] args, object options)
        {
            bool hadError = false;

            ValueContainer   valueContainer = options as ValueContainer;
            StringEnumerator arguments      = new StringEnumerator(args);

            while (arguments.MoveNext())
            {
                string argument = arguments.Current;

                if (argument != null && argument.Length > 0)
                {
                    IParser parser = CreateParser(argument);

                    if (parser != null)
                    {
                        ParseResult result = parser.Parse(arguments, this.m_optionMap, options);

                        if ((result & ParseResult.Failure) == ParseResult.Failure)
                        {
                            return(false);
                        }

                        if ((result & ParseResult.MoveOnNextElement) == ParseResult.MoveOnNextElement)
                        {
                            arguments.MoveNext();
                        }
                    }
                    else
                    {
                        if (valueContainer != null)
                        {
                            valueContainer.Values.Add(argument);
                        }
                    }
                }
            }

            hadError |= !CheckRules(this.m_optionMap);
            return(!hadError);
        }
예제 #3
0
            public ParseResult Parse(StringEnumerator argumentEnumerator, IDictionary map, object options)
            {
                LetterEnumerator group = new LetterEnumerator(argumentEnumerator.Current.Substring(1));

                while (group.MoveNext())
                {
                    OptionInfo option = (OptionInfo)map[group.Current];

                    if (option == null)
                    {
                        return(ParseResult.Failure);
                    }

                    option.IsDefined = true;

                    if (!option.IsBoolean)
                    {
                        if (argumentEnumerator.IsLast && group.IsLast)
                        {
                            return(ParseResult.Failure);
                        }

                        if (!group.IsLast)
                        {
                            if (option.SetValue(group.SubstringFromNext(), options))
                            {
                                return(ParseResult.Success);
                            }
                            else
                            {
                                return(ParseResult.Failure);
                            }
                        }

                        if (!argumentEnumerator.IsLast && !IsInputValue(argumentEnumerator.Next))
                        {
                            return(ParseResult.Failure);
                        }
                        else
                        {
                            if (option.SetValue(argumentEnumerator.Next, options))
                            {
                                return(ParseResult.Success | ParseResult.MoveOnNextElement);
                            }
                            else
                            {
                                return(ParseResult.Failure);
                            }
                        }
                    }
                    else
                    {
                        if (!group.IsLast && map[group.Next] == null)
                        {
                            return(ParseResult.Failure);
                        }

                        if (!option.SetValue(true, options))
                        {
                            return(ParseResult.Failure);
                        }
                    }
                }

                return(ParseResult.Success);
            }