public object[] GetValues(string name)
        {
            NormalizeName(ref name);
            ArgSpec argSpec = (ArgSpec)_args[name];
            Type    t       = argSpec.IsInteger ? typeof(long) :
                              argSpec.IsHexNumber ? typeof(long) :
                              typeof(string);

            return((object[])((ArrayList)GetValue(name, new ArrayList())).ToArray(t));
        }
        private bool ParseNamedArg(string arg)
        {
            Match m = Regex.Match(arg, @"^/(-)?([a-z0-9]+)(?:\:(.+))?$");

            if (!m.Success)
            {
                return(AddError(ERROR_UNPARSEABLE_ARG, arg, null, null));
            }
            bool   unset    = m.Groups[1].Success;
            string argName  = m.Groups[2].Value;
            string argValue = (m.Groups[3].Success) ? m.Groups[3].Value : null;

            NormalizeName(ref argName);

            _argsPresent.Add(argName);

            ArgSpec   argSpec = (ArgSpec)_args[argName];
            ErrorType err     =
                (argSpec == null) ? ERROR_UNRECOGNIZED_ARG :
                (argSpec.IsFlag && argValue != null) ? ERROR_FLAG_HAD_VALUE :
                (argSpec.IsRequired && argValue == null) ? ERROR_VALUE_REQUIRED :
                (!argSpec.IsUnsettable && unset) ? ERROR_UNRECOGNIZED_ARG :
                null;

            if (err != null)
            {
                return(AddError(err, arg, argName, argValue));
            }

            object parsedValue = null;

            if (argSpec.IsFlag)
            {
                parsedValue = !unset;
            }
            else if (argSpec.IsInteger)
            {
                try { parsedValue = long.Parse(argValue, CultureInfo.InvariantCulture); }
                catch { err = ERROR_NOT_AN_INT; }
            }
            else if (argSpec.IsHexNumber)
            {
                try { parsedValue = long.Parse(argValue, NumberStyles.AllowHexSpecifier | NumberStyles.HexNumber, CultureInfo.InvariantCulture); }
                catch { err = ERROR_NOT_HEX_INT; }
            }
            else
            {
                parsedValue = argValue;
            }
            if (err != null)
            {
                return(AddError(err, arg, argName, argValue));
            }

            if (!argSpec.IsMultiple)
            {
                _values[argName] = parsedValue;
            }
            else
            {
                ArrayList values = (ArrayList)_values[argName];
                if (values == null)
                {
                    values           = new ArrayList();
                    _values[argName] = values;
                }
                values.Add(parsedValue);
            }
            return(true);
        }