示例#1
0
 static void InitShortNamesCacheRange(char first, char last)
 {
     for (var ch = first; ch <= last; ch++)
     {
         ShortNamesCache[ch] = new OptionNames(ShortOptionName.Parse(ch), null, null);
     }
 }
示例#2
0
文件: OptionSpec.cs 项目: vokhub/Arqs
 OptionSpec(OptionNames names, bool isFlag, bool isLongNameNegatable, bool isValueOptional, string valueName, string description)
 {
     Names  = names ?? throw new ArgumentNullException(nameof(names));
     IsFlag = isFlag;
     IsLongNameNegatable = isLongNameNegatable;
     IsValueOptional     = isValueOptional;
     ValueName           = valueName;
     Description         = description;
 }
示例#3
0
文件: OptionSpec.cs 项目: vokhub/Arqs
        public static OptionSpec Parse(string spec, ParseOptions options)
        {
            var tokens = spec.Split((char[])null, 2, StringSplitOptions.RemoveEmptyEntries);

            var description = tokens.Length > 1 && tokens[1].Length > 0 ? tokens[1] : null;

            var    names = tokens[0].Split(PipeSeparator, 3, StringSplitOptions.RemoveEmptyEntries);
            string name1 = null, name2 = null, name3 = null, valueName = null;
            var    isValueOptional     = false;
            var    isFlag              = false;
            var    isLongNameNegatable = false;

            var i = 0;

            foreach (var name in names)
            {
                var nameToken = name;

                var ei = name.IndexOf('=');
                if (ei < 0)
                {
                    if ((options & ParseOptions.ForbidFlag) == ParseOptions.ForbidFlag)
                    {
                        throw new ArgumentException("Invalid option specification.", nameof(spec));
                    }

                    isFlag = true;
                }
                else
                {
                    if ((options & ParseOptions.ForbidValue) == ParseOptions.ForbidValue)
                    {
                        throw new ArgumentException("Invalid option specification.", nameof(spec));
                    }

                    isFlag = false;

                    var bi = name.IndexOf('[');

                    if (ei == 0 || bi == 0)
                    {
                        throw new ArgumentException("Option specification is missing name.", nameof(spec));
                    }

                    if (bi > 0 && name[name.Length - 1] != ']')
                    {
                        throw new ArgumentException("Option specification has invalid syntax (missing ']').", nameof(spec));
                    }

                    isValueOptional = bi > 0 && bi + 1 == ei;
                    if (ei > 0)
                    {
                        nameToken = name.Substring(0, bi > 0 ? bi : ei);
                        var valueNameLength = name.Length - (ei + 1) - (isValueOptional ? 1 : 0);
                        if (valueNameLength > 0)
                        {
                            valueName = name.Substring(ei + 1, valueNameLength);
                        }
                    }
                }

                const string noPrefix = "[no-]";

                if (nameToken.Length > noPrefix.Length && nameToken.StartsWith(noPrefix, StringComparison.Ordinal))
                {
                    if ((options & ParseOptions.ForbidNoPrefix) == ParseOptions.ForbidNoPrefix)
                    {
                        throw new ArgumentException("Invalid option specification.", nameof(spec));
                    }

                    if (!isFlag)
                    {
                        throw new ArgumentException("Non-flag option specification cannot specify the \"[no-]\" prefix in its long name.", nameof(spec));
                    }

                    nameToken           = nameToken.Substring(noPrefix.Length);
                    isLongNameNegatable = true;
                }

                switch (i)
                {
                case 0: name1 = nameToken; break;

                case 1: name2 = nameToken; break;

                case 2: name3 = nameToken; break;

                default: Debug.Fail($"0 <= '{nameof(i)}' < 3"); break;
                }

                i++;
            }

            return(new OptionSpec(OptionNames.Guess(name1, name2, name3),
                                  isFlag, isLongNameNegatable,
                                  isValueOptional, valueName, description));
        }