예제 #1
0
        static void Main(string[] args)
        {
            Console.WriteLine("Welcome to the Calculator app!");
            Console.ReadLine();
            string       argumentOne;
            string       argumentTwo;
            ArgumentType argument1Type = ArgumentType.String;
            ArgumentType argument2Type = ArgumentType.String;

            argumentOne   = GetArgument("Please input first argument: ");
            argumentTwo   = GetArgument("Please input second argument: ");
            argument1Type = GetArgumentType(argumentOne);
            argument2Type = GetArgumentType(argumentTwo);

            Console.WriteLine("Argument 1 is {0}", argument1Type);
            Console.WriteLine("Argument 2 is {0}", argument2Type);
            Console.ReadKey();

            OperatorType operatorType = OperatorType.Unknown;

            operatorType = GetOperatorType("Please input your operator");
            Console.WriteLine("Your operator is {0}", operatorType);
            Console.ReadKey();

            Calculator(argumentOne, argument1Type, argumentTwo, argument2Type, operatorType);
        }
예제 #2
0
        public static ArgumentType GetArgumentType(string argument)
        {
            ArgumentType argumentType = ArgumentType.String;
            double       number;
            DateTime     dateTime;
            TimeSpan     timeSpan;

            if (double.TryParse(argument, out number))
            {
                argumentType = ArgumentType.Number;
                return(argumentType);
            }
            else if (TimeSpan.TryParse(argument, out timeSpan))
            {
                argumentType = ArgumentType.TimeSpan;
                return(argumentType);
            }
            else if (DateTime.TryParse(argument, out dateTime))
            {
                argumentType = ArgumentType.DateTime;
                return(argumentType);
            }
            else
            {
                argumentType = ArgumentType.String;
                return(argumentType);
            }
        }
예제 #3
0
        private ArgumentSummary Summarize(ArgumentDefinition arg)
        {
            var attrib      = arg.Attribute;
            var namedAttrib = arg.Attribute as NamedArgumentAttribute;
            var enumType    = arg.ArgumentType as IEnumArgumentType;

            var isCommand = false;
            var type      = arg.ArgumentType.Type;

            if (type.GetTypeInfo().IsGenericType&&
                type.GetGenericTypeDefinition().Name == "CommandGroup`1")
            {
                enumType  = ArgumentType.GetType(type.GetGenericArguments().First()) as IEnumArgumentType;
                isCommand = true;
            }

            return(new ArgumentSummary
            {
                name = attrib.LongName,
                short_name = namedAttrib?.ShortName,
                required = arg.IsRequired,
                command = isCommand,
                takes_rest_of_line = arg.TakesRestOfLine,
                type = arg.ArgumentType.DisplayName,
                description = attrib.Description,
                default_value = arg.HasDefaultValue ? attrib.DefaultValue : null,
                possible_values = enumType?.GetValues()
                                  .Where(value => !value.Hidden && !value.Disallowed)
                                  .Select(value => Summarize(arg, value))
                                  .ToArray(),
            });
        }
        public object Get(ArgumentType type)
        {
            object result = null;

            arguments?.TryGetValue(type, out result);
            return(result);
        }
예제 #5
0
        private string ArgTypeConverter(ArgumentType type)
        {
            switch (type)
            {
            case ArgumentType.boolean:
                return("Boolean");

            case ArgumentType.text:
                return("Text");

            case ArgumentType.number:
                return("Number");

            case ArgumentType.datetime:
                return("DateTime");

            case ArgumentType.collection:
                return("Text Collection");

            case ArgumentType.unknown:
                return("A magic type!");

            default:
                break;
            }
            throw new InvalidOperationException(type.ToString());
        }
예제 #6
0
            public Argument(ArgumentAttribute attribute, FieldInfo field, ErrorReporter reporter)
            {
                this.longName = Parser.LongName (attribute, field);
                this.explicitShortName = Parser.ExplicitShortName (attribute);
                this.shortName = Parser.ShortName (attribute, field);
                this.hasHelpText = Parser.HasHelpText (attribute);
                this.helpText = Parser.HelpText (attribute);
                this.defaultValue = Parser.DefaultValue (attribute);
                this.elementType = ElementType (field);
                this.flags = Flags (attribute, field);
                this.field = field;
                this.SeenValue = false;
                this.reporter = reporter;
                this.isDefault = attribute != null && attribute is DefaultArgumentAttribute;

                if (this.IsCollection)
                    this.collectionValues = new ArrayList ();

                Debug.Assert (!String.IsNullOrEmpty (this.longName));
                Debug.Assert (!this.isDefault || !this.ExplicitShortName);
                Debug.Assert (!this.IsCollection || this.AllowMultiple, "Collection arguments must have allow multiple");
                Debug.Assert (!this.Unique || this.IsCollection, "Unique only applicable to collection arguments");
                Debug.Assert (IsValidElementType (this.Type) ||
                              IsCollectionType (this.Type));
                Debug.Assert ((this.IsCollection && IsValidElementType (this.elementType)) ||
                              (!this.IsCollection && this.elementType == null));
                Debug.Assert (!(this.IsRequired && this.HasDefaultValue), "Required arguments cannot have default value");
                Debug.Assert (!this.HasDefaultValue || (this.defaultValue.GetType () == field.FieldType),
                              "Type of default value must match field type");
            }
예제 #7
0
        public static Dictionary <ArgumentType, string> Parse(string[] args)
        {
            var result = new Dictionary <ArgumentType, string>();

            foreach (var a in args)
            {
                var          split   = a.Split(new[] { ':' }, 2);
                ArgumentType argType = ArgumentType.Default;
                switch (split[0])
                {
                case "-sf": argType = ArgumentType.SourceFileName; break;

                case "-s": argType = ArgumentType.SplittedFileSize; break;

                case "-d": argType = ArgumentType.DestinationFolder; break;

                default:
                    throw new ArgumentException($"Not registered argument passed: {split[0]}.");
                }
                if (argType != ArgumentType.Default)
                {
                    result.Add(argType, split[1]);
                }
            }
            return(result);
        }
예제 #8
0
        public override string ToString()
        {
            string display;

            if (Optional)
            {
                display = "[";
            }
            else
            {
                display = "<";
            }

            display += StringUtil.ToUppercaseFirst(ArgumentType.ToString());

            if (Optional)
            {
                display += "]";
            }
            else
            {
                display += ">";
            }

            return(display);
        }
예제 #9
0
        internal string ToString(bool typed)
        {
            if (m_argumentType == null)
            {
                return(base.ToString() !);
            }

            if (ArgumentType.IsEnum)
            {
                return(typed ? $"{Value}" : $"({ArgumentType.FullName}){Value}");
            }

            if (Value == null)
            {
                return(typed ? "null" : $"({ArgumentType.Name})null");
            }

            if (ArgumentType == typeof(string))
            {
                return($"\"{Value}\"");
            }

            if (ArgumentType == typeof(char))
            {
                return($"'{Value}'");
            }

            if (ArgumentType == typeof(Type))
            {
                return($"typeof({((Type)Value!).FullName})");
            }

            if (ArgumentType.IsArray)
            {
                IList <CustomAttributeTypedArgument> array = (IList <CustomAttributeTypedArgument>)Value !;
                Type elementType = ArgumentType.GetElementType() !;

                var result = new ValueStringBuilder(stackalloc char[256]);
                result.Append("new ");
                result.Append(elementType.IsEnum ? elementType.FullName : elementType.Name);
                result.Append('[');
                result.Append(array.Count.ToString());
                result.Append(']');

                for (int i = 0; i < array.Count; i++)
                {
                    if (i != 0)
                    {
                        result.Append(", ");
                    }
                    result.Append(array[i].ToString(elementType != typeof(object)));
                }

                result.Append(" }");

                return(result.ToString());
            }

            return(typed ? $"{Value}" : $"({ArgumentType.Name}){Value}");
        }
예제 #10
0
 internal static XDRPCArgumentInfo GenerateArgumentInfo(
     Type t,
     object o,
     ArgumentType at)
 {
     return(XDRPCMarshaler.GenerateArgumentInfo(t, o, at, 0));
 }
예제 #11
0
 /// <summary>
 /// Formats the argument into a string.
 /// </summary>
 /// <param name="value">Value to format.</param>
 /// <param name="suppressArgNames">True to suppress argument names;
 /// false to leave them in.</param>
 /// <returns>The formatted string.</returns>
 public IEnumerable <string> Format(object value, bool suppressArgNames = false)
 {
     if (CollectionArgumentType != null)
     {
         foreach (var item in CollectionArgumentType.ToEnumerable(value))
         {
             if (suppressArgNames)
             {
                 yield return(CollectionArgumentType.ElementType.Format(item));
             }
             else
             {
                 yield return(Format(CollectionArgumentType.ElementType, item));
             }
         }
     }
     else if (suppressArgNames)
     {
         yield return(ArgumentType.Format(value));
     }
     else
     {
         yield return(Format(ArgumentType, value));
     }
 }
예제 #12
0
 public static void ThrowArgumentNegativeOrZero(
     double value, string argumentName, ArgumentType argumentType)
 {
     throw new ArgumentOutOfRangeException(
               $"{GetArgumentTypeName(argumentType)} {argumentName}={value} must be greater than zero",
               (Exception)null);
 }
예제 #13
0
 public override void Write(MetadataBuffer buffer, IBinaryStreamWriter writer)
 {
     writer.WriteByte((byte)ArgumentMemberType);
     ArgumentType.Write(buffer, writer); // TODO: write FieldOrPropType instead.
     writer.WriteSerString(MemberName);
     Argument.Write(buffer, writer);
 }
        static ArgumentType GetArgumentType(string argument)
        {
            ArgumentType typeToCheck = ArgumentType.String;
            int          intVal;
            DateTime     dateTimeVal;
            TimeSpan     timeSpanVal;

            bool isInt         = int.TryParse(argument, out intVal);
            bool isDateTimeVal = DateTime.TryParse(argument, out dateTimeVal);
            bool isTimeSpan    = TimeSpan.TryParse(argument, out timeSpanVal);

            if (isInt)
            {
                typeToCheck = ArgumentType.Number;
            }
            else if (isTimeSpan)
            {
                typeToCheck = ArgumentType.TimeSpan;
            }
            else if (isDateTimeVal)
            {
                typeToCheck = ArgumentType.DateTime;
            }


            else
            {
                return(typeToCheck);
            }



            return(typeToCheck);
        }
예제 #15
0
        private void Initialize()
        {
            commandInfos = new List <CommandInfo>();
            properties   = new List <ParameterInfo>();

            foreach (var propertyInfo in ArgumentType.GetProperties(BindingFlags.Instance | BindingFlags.Public))
            {
                var attributes = propertyInfo.GetCustomAttributes <CommandLineAttribute>(true).ToArray();
                if (attributes.Any())
                {
                    var parameterInfo = CreateInfo(propertyInfo, attributes);
                    properties.Add(parameterInfo);

                    if (parameterInfo is CommandInfo commandInfo)
                    {
                        commandInfos.Add(commandInfo);
                        if (IsHelpCommand(propertyInfo))
                        {
                            HelpCommand = commandInfo;
                        }
                        if (commandInfo.IsDefault)
                        {
                            if (DefaultCommand != null)
                            {
                                throw new InvalidOperationException("Default command was defined twice.");
                            }

                            DefaultCommand = commandInfo;
                        }
                    }
                }
            }
        }
예제 #16
0
 public override uint GetPhysicalLength()
 {
     return(sizeof(byte) +
            ArgumentType.GetPhysicalLength() +
            (MemberName == null ? sizeof(byte) : MemberName.GetSerStringSize()) +
            Argument.GetPhysicalLength());
 }
예제 #17
0
        private IParsingResultsDictionary parseConfigFromCommandLine()
        {
            var arguments          = new Queue <string>(_source.Args);
            var plainValueCounter  = 0;
            var resultsBuilder     = new ParsingResultsBuilder(_source.DuplicateKeyBehavior);
            var lastArgumentString = _source.Args.First();

            while (arguments.Any())
            {
                var currentArgumentString = arguments.Dequeue();
                var parsedArgument        = ArgumentType.CreateFrom(currentArgumentString);
                switch (parsedArgument)
                {
                case ArgumentType.SingleDash dashArgument:
                    handleSingleDashArgument(resultsBuilder, arguments, dashArgument);
                    break;

                case ArgumentType.DoubleDash doubleDashArgument:
                    handleDoubledashArgument(resultsBuilder, arguments, doubleDashArgument);
                    break;

                case ArgumentType.Assignment assignment:
                    if (_source.AllowDirectAssignments)
                    {
                        resultsBuilder.Add(assignment.Key, assignment.Value);
                    }
                    else
                    {
                        resultsBuilder.Error(new NotSupportedException($"Invalid argument '{assignment.Argument}' as direct assignments are not allowed."));
                    }
                    break;

                case ArgumentType.Invalid invalid:
                    resultsBuilder.Error(new ParsingException("Invalid argument.", $"Argument somewhere near: '{lastArgumentString.Limit(16)}'"));
                    break;

                case ArgumentType.Plain plain:
                    if (plainValueCounter < _valueDefinitions.Count)
                    {
                        resultsBuilder.Add(_valueDefinitions[plainValueCounter], plain.Argument);
                    }
                    else
                    {
                        resultsBuilder.Error(new IndexOutOfRangeException($"No more than {_valueDefinitions.Count} value arguments are allowed."));
                    }

                    plainValueCounter++;
                    break;
                }

                lastArgumentString = currentArgumentString;
            }

            if (_valueDefinitions.Count > plainValueCounter)
            {
                resultsBuilder.Error(new ValueRequiredException(string.Empty, $"Not all required values have been provided. Expected: {_valueDefinitions.Count}, Provided: {plainValueCounter}"));
            }

            return(resultsBuilder.GetResults());
        }
        public override LocalBuilder BuildArguments(ILGenerator ilGenerator)
        {
            LocalBuilder           methodLocalBuilder    = null;
            FieldBuilder           contractFieldBuilder  = null;
            LocalBuilder           aspectArgLocalBuilder = null;
            AspectArgsMethodWeaver methodWeaver          = null;
            ConstructorInfo        ctorInterceptionArgs  = null;

            methodLocalBuilder = LocalBuilderRepository.Declare(() => {
                return(ilGenerator.DeclareLocal(typeof(MethodInfo)));
            });

            aspectArgLocalBuilder = ilGenerator.DeclareLocal(ArgumentType);
            contractFieldBuilder  = WeavingSettings.TypeDefinition.GetFieldBuilder(WeavingSettings.ContractType);
            methodWeaver          = new AspectArgsMethodWeaver(Member, methodLocalBuilder, Parameters, aspectWeavingSettings);
            methodWeaver.Weave(ilGenerator);
            ilGenerator.EmitLoadArg(0);
            ilGenerator.Emit(OpCodes.Ldfld, contractFieldBuilder);
            ilGenerator.EmitLoadLocal(methodLocalBuilder);
            ctorInterceptionArgs = ArgumentType.GetConstructors()[0];

            Parameters.ForEach(1, (parameter, i) => {
                ilGenerator.EmitLoadArg(i);

                if (parameter.IsByRef)
                {
                    ilGenerator.Emit(OpCodes.Ldind_I4);
                }
            });

            ilGenerator.Emit(OpCodes.Newobj, ctorInterceptionArgs);
            ilGenerator.EmitStoreLocal(aspectArgLocalBuilder);

            return(aspectArgLocalBuilder);
        }
        public override LocalBuilder BuildArguments(ILGenerator ilGenerator)
        {
            LocalBuilder    propertyLocalBuilder          = null;
            FieldBuilder    contractFieldBuilder          = null;
            LocalBuilder    aspectArgLocalBuilder         = null;
            ConstructorInfo ctorInterceptionArgs          = null;
            AbstractAspectPropertyArgsWeaver methodWeaver = null;

            propertyLocalBuilder = LocalBuilderRepository.Declare(() => {
                return(ilGenerator.DeclareLocal(typeof(PropertyInfo)));
            });

            ctorInterceptionArgs  = ArgumentType.GetConstructors()[0];
            aspectArgLocalBuilder = ilGenerator.DeclareLocal(ArgumentType);
            contractFieldBuilder  = WeavingSettings.TypeDefinition.GetFieldBuilder(WeavingSettings.ContractType);
            methodWeaver          = new AspectArgsSetPropertyWeaver(Member, propertyLocalBuilder, aspectWeavingSettings);
            methodWeaver.Weave(ilGenerator);
            ilGenerator.EmitLoadArg(0);
            ilGenerator.Emit(OpCodes.Ldfld, contractFieldBuilder);
            ilGenerator.EmitLoadLocal(propertyLocalBuilder);
            ilGenerator.Emit(OpCodes.Ldsfld, BindingsDependency);
            ilGenerator.EmitLoadArg(1);
            ilGenerator.Emit(OpCodes.Newobj, ctorInterceptionArgs);
            ilGenerator.EmitStoreLocal(aspectArgLocalBuilder);

            return(aspectArgLocalBuilder);
        }
 /// <inheritdoc />
 public override uint GetPhysicalLength(MetadataBuffer buffer)
 {
     return(sizeof(byte) +
            ArgumentType.GetPhysicalLength(buffer) +
            (MemberName?.GetSerStringSize() ?? sizeof(byte)) +
            Argument.GetPhysicalLength(buffer));
 }
예제 #21
0
        public void Execute()
        {
            ParseFileNames();
            List <ArgumentOption> argumentOptions = GetArgumentOptions();
            bool isArgumentTypesNotSimular        = argumentOptions.Select(ao => ao.Type).Distinct().Count() != 1;

            if (isArgumentTypesNotSimular)
            {
                throw new ApplicationException("Arguments must be only input or output options");
            }

            ArgumentType type = argumentOptions.First().Type;

            if (type == ArgumentType.Input)
            {
                argumentOptions.Reverse();
            }

            IInputStream  inputStream  = new FileInputStream(_inputFileName);
            IOutputStream outputStream = new FileOutputStream(_outputFileName);

            DecorateByArgumentOptions(argumentOptions, ref inputStream, ref outputStream);

            WriteFromTo(inputStream, outputStream);

            inputStream.Dispose();
            outputStream.Dispose();
        }
예제 #22
0
 public Argument(ArgumentType argumentType, string term, string value, bool isLongTerm = false)
 {
     ArgumentType = argumentType;
     Term         = term;
     Value        = value;
     IsLongTerm   = isLongTerm;
 }
예제 #23
0
 public static void ThrowArgumentOutOfRangeException(
     double value, double minValue, double maxValue, string argumentName, ArgumentType argumentType)
 {
     throw new ArgumentOutOfRangeException(
               $"{GetArgumentTypeName(argumentType)} {argumentName}={value} is out of range [{minValue}, {maxValue}]",
               (Exception)null);
 }
예제 #24
0
 public PrepositionArgInfo(string preposition, ArgumentType argumentType, string fillerType)//:this(false,preposition, ArgumentType,argumentType,fillerType)
 {
     _passiveSentence = false;
     _preposition     = preposition;
     _argumentType    = argumentType;
     _fillerType      = fillerType;
 }
        public static string GetPropertyValuePath(ArgumentType argumentType)
        {
            switch (argumentType)
            {
            case ArgumentType.Bool:
                return("m_BoolValue");

            case ArgumentType.Int:
                return("m_IntValue");

            case ArgumentType.Float:
                return("m_FloatValue");

            case ArgumentType.String:
                return("m_StringValue");

            case ArgumentType.Vector2:
                return("m_Vector2Value");

            case ArgumentType.Vector3:
                return("m_Vector3Value");

            case ArgumentType.Color:
                return("m_ColorValue");

            case ArgumentType.Object:
                return("m_ObjectValue");

            default:
                return(string.Empty);
            }
        }
예제 #26
0
 public PrepositionArgInfo(bool passiveSentence, string preposition, ArgumentType argumentType, string fillerType)
 {
     _passiveSentence = passiveSentence;
     _preposition     = preposition;
     _argumentType    = argumentType;
     _fillerType      = fillerType;
 }
예제 #27
0
        public ArgumentDef(
            char shortName,
            string longName,
            Type dataType            = null,
            ArgumentType argType     = ArgumentType.Positional,
            ArgumentStatus argStatus = ArgumentStatus.Required,
            sbyte consumption        = 0
            )
        {
            if (shortName == nullChar && longName == emptyString)
            {
                throw new Exception("Argument must have a ShortName, LongName, or both.");
            }

            if (argType == ArgumentType.Positional && consumption == 0)
            {
                throw new Exception("Invalid number of values for positional argument '{0}'.  Positional arguments must be represented by at least one value.");
            }

            if (dataType == null)
            {
                dataType = typeof(object);
            }

            this._dataType   = null;
            this.ShortName   = shortName;
            this.LongName    = longName;
            this.ArgType     = argType;
            this.ArgStatus   = argStatus;
            this.Consumption = consumption;

            this.DataType = dataType;
        }
예제 #28
0
 public Argument(Int32 categoryID, Int32 entryID, String message)
 {
     this._categoryID = categoryID;
     this._entryID    = entryID;
     this._message    = message;
     this._type       = ArgumentType.Reference;
 }
        public override void Weave(ILGenerator ilGenerator)
        {
            LocalBuilder argsImplLocalBuilder = null;
            var          ctorInterceptionArgs = ArgumentType.GetConstructors()[0];
            var          aspectArgsType       = Member.ToAspectArgumentContract();
            var          methodProperty       = aspectArgsType.GetProperty("Method");

            argsImplLocalBuilder = LocalBuilderRepository.GetOrDeclare(ArgumentType, () => {
                return(ilGenerator.DeclareLocal(ArgumentType));
            });

            ilGenerator.EmitLoadArg(1);
            ilGenerator.Emit(OpCodes.Ldind_Ref);
            WeaveAspectArg(ilGenerator);
            ilGenerator.Emit(OpCodes.Callvirt, methodProperty.GetGetMethod());
            ilGenerator.Emit(OpCodes.Ldsfld, bindingsDependency);

            Parameters.ForEach(1, (parameter, i) => {
                var property = aspectArgsType.GetProperty("Arg{0}".Fmt(i));

                WeaveAspectArg(ilGenerator);
                ilGenerator.Emit(OpCodes.Callvirt, property.GetGetMethod());
            });

            ilGenerator.Emit(OpCodes.Newobj, ctorInterceptionArgs);
            ilGenerator.EmitStoreLocal(argsImplLocalBuilder);
        }
예제 #30
0
        public void TestThatDependentTypesListIsCorrect()
        {
            var type = (TupleArgumentType)ArgumentType.GetType(typeof(Tuple <bool, int, bool>));

            type.DependentTypes.Should().BeEquivalentTo(
                new[] { typeof(bool), typeof(int) }.Select(ArgumentType.GetType));
        }
예제 #31
0
            public Argument(ArgumentAttribute attribute, FieldInfo field, ErrorReporter reporter)
            {
                this.longName          = Parser.LongName(attribute, field);
                this.explicitShortName = Parser.ExplicitShortName(attribute);
                this.shortName         = Parser.ShortName(attribute, field);
                this.hasHelpText       = Parser.HasHelpText(attribute);
                this.helpText          = Parser.HelpText(attribute);
                this.defaultValue      = Parser.DefaultValue(attribute);
                this.elementType       = ElementType(field);
                this.flags             = Flags(attribute, field);
                this.field             = field;
                this.seenValue         = false;
                this.reporter          = reporter;
                this.isDefault         = attribute != null && attribute is DefaultArgumentAttribute;

                if (this.IsCollection)
                {
                    this.collectionValues = new ArrayList();
                }

                Debug.Assert(!string.IsNullOrEmpty(this.longName), "Long name");
                Debug.Assert(!this.isDefault || !this.ExplicitShortName, "Short name");
                Debug.Assert(!this.IsCollection || this.AllowMultiple, "Collection arguments must have allow multiple");
                Debug.Assert(!this.Unique || this.IsCollection, "Unique only applicable to collection arguments");
                Debug.Assert(IsValidElementType(Type) || IsCollectionType(Type), "Collection Type or Element type");
                Debug.Assert((this.IsCollection && IsValidElementType(this.elementType)) || (!this.IsCollection && this.elementType == null), "Element type or Collection Type");
                Debug.Assert(!(this.IsRequired && this.HasDefaultValue), "Required arguments cannot have default value");
                Debug.Assert(!this.HasDefaultValue || (this.defaultValue.GetType() == field.FieldType), "Type of default value must match field type");
            }
 internal CommandLineArgumentAttribute(ArgumentType argType, string name)
 {
     _argumentType = argType;
     Name = name;
     Shortcut = string.Empty;
     Description = string.Empty;
     ParameterDescription = string.Empty;
 }
 // ----------------------------------------------------------------------
 public ToggleArgument( ArgumentType argumentType, string name, bool defaultValue )
     : base(argumentType | ArgumentType.HasName | ArgumentType.ContainsValue, name, defaultValue)
 {
     if ( name == null )
     {
         throw new ArgumentNullException( "name" );
     }
 }
예제 #34
0
        protected virtual void OnProcessArgument( ArgumentType type, string value )
        {
            ProcessArgumentHandler handler = null;

            if ( type == ArgumentType.Parameter )
                handler = ProcessParameter;
            else
                handler = ProcessOption;

            if ( handler != null ) handler( this, new ProcessArgumentEventArgs( type, value ) );
        }
예제 #35
0
        public Instruction GenericInst(OpCodes code, AddressingModes addrMode, Action<GenericInstruction, int, int> exec, ArgumentType param1type = ArgumentType.None, ArgumentType param2type = ArgumentType.None)
        {
            var inst = new GenericInstruction(cpu, code, addrMode, param1type != ArgumentType.None) { runFunction = exec };

            if (param1type != ArgumentType.None)
            {
                inst.decodeArgumentsFunction = delegate(GenericInstruction sender, Memory.MemoryBin bin, ref InstructionDecodeContext context, ref int offset, ref int param1, ref int param2)
                {
                    switch (param1type)
                    {
                        case ArgumentType.None:
                            break;
                        default:
                        case ArgumentType.I1:
                            param1 = inst.DecodeInt1Argument(bin, ref offset);
                            break;
                        case ArgumentType.I2:
                            param1 = inst.DecodeInt2Argument(bin, ref offset);
                            break;
                        case ArgumentType.I3:
                            param1 = inst.DecodeInt3Argument(bin, ref offset);
                            break;
                    }

                    switch (param2type)
                    {
                        case ArgumentType.None:
                            break;
                        default:
                        case ArgumentType.I1:
                            param2 = inst.DecodeInt1Argument(bin, ref offset);
                            break;
                        case ArgumentType.I2:
                            param2 = inst.DecodeInt2Argument(bin, ref offset);
                            break;
                        case ArgumentType.I3:
                            param2 = inst.DecodeInt3Argument(bin, ref offset);
                            break;
                    }
                };
            }

            return inst;
        }
        internal List<string> ParseCommandLine(List<ProgramOption> optionList, string[] args)
        {
            /* initialize for new parsing */
            expectedArgType = ArgumentType.ANY;
            ProcessOptions(optionList);
            List<string> arguments = new List<string>();

            for (int argsPosition = 0; argsPosition < args.Length; argsPosition++) {
                string arg = args[argsPosition];
                ArgumentType currentArgType = GetArgumentType(arg);
                switch (currentArgType) {
                    case ArgumentType.ARGUMENT:
                        ParseArgument(arg, arguments);
                        break;

                    case ArgumentType.OPTION_SHORT:
                        ParseShortOption(arg);
                        break;

                    case ArgumentType.OPTION_LONG:
                        bool continueParsing = ParseLongOption(arg);
                        if (!continueParsing) {
                            arguments.AddRange(args.Skip(argsPosition + 1));
                            argsPosition = args.Length;
                        }
                        break;

                    default:
                        /* should not happen as GetArgumentType(arg) returns only one from the above options (cases) */
                        throw new NotSupportedException("Unexpected currentArgType");
                }
            }
            Log("\nPLAIN ARGUMENTS:");
            Log(string.Join("\n", arguments.ToArray()));
            return arguments;// as they are local variable for now (and not private parser field), we dont need to: new List<string>(arguments);
        }
예제 #37
0
 /// <summary>
 /// Creates a new CommandLineArgument instance
 /// </summary>
 /// <param name="name">The name of the argument</param>
 /// <param name="type">The argument type</param>
 /// <param name="shortDescription">The arguments short description</param>
 /// <param name="longDescription">The arguments long description</param>
 /// <param name="defaultValue">The default value of the argumen</param>
 /// <param name="aliases">A list of aliases for the command</param>
 /// <param name="values">A list of valid values for the command</param>
 public CommandLineArgument(string name, ArgumentType type, string shortDescription, string longDescription, string defaultValue, string[] aliases, string[] values)
     : this(name, type, shortDescription, longDescription, defaultValue)
 {
     m_aliases = aliases;
     m_validValues = values;
 }
예제 #38
0
 public ArgumentInstance(object value)
 {
     Constraint = Is.Anything();
     Type = ArgumentType.ArgumentOut;
     ReturnValue = value;
 }
 /// <summary>
 ///     Allows control of command line parsing.
 /// </summary>
 /// <param name="type"> Specifies the error checking to be done on the argument. </param>
 public LocalizedArgumentAttribute(ArgumentType type) : base(type)
 {
 }
예제 #40
0
 public ArgumentInfo(ArgumentType argKind, string argName)
 {
     ContractUtils.Requires((argKind == ArgumentType.Named) ^ (argName == null), "kind");
     kind = argKind;
     name = argName;
 }
예제 #41
0
 public ArgumentInstance(AbstractConstraint constraint)
 {
     Constraint = constraint;
     Type = ArgumentType.ArgumentIn;
     ReturnValue = null;
 }
예제 #42
0
		// ----------------------------------------------------------------------
		protected Argument( ArgumentType argumentType, string name, object defaultValue )
		{
			this.name = name;
			this.argumentType = argumentType;
			this.defaultValue = defaultValue;
		} // Argument
예제 #43
0
 /// <summary>
 /// Creates a new CommandLineArgument instance
 /// </summary>
 /// <param name="name">The name of the argument</param>
 /// <param name="type">The argument type</param>
 /// <param name="shortDescription">The arguments short description</param>
 /// <param name="longDescription">The arguments long description</param>
 public CommandLineArgument(string name, ArgumentType type, string shortDescription, string longDescription)
     : this(name, type)
 {
     m_shortDescription = shortDescription;
     m_longDescription = longDescription;
 }
예제 #44
0
 public ClassifiedArgument(ArgumentType argumentType, CommandParameterInfo parameterInfo, string value)
 {
     this.ArgumentType = argumentType;
     this.ParameterInfo = parameterInfo;
     this.Value = value;
 }
예제 #45
0
            public Argument(ArgumentAttribute attribute, FieldInfo field, ErrorReporter reporter)
            {
                _longName = CommandLineParser.LongName(attribute, field);
                _explicitShortName = CommandLineParser.ExplicitShortName(attribute);
                _shortName = CommandLineParser.ShortName(attribute, field);
                _hasHelpText = CommandLineParser.HasHelpText(attribute);
                _helpText = CommandLineParser.HelpText(attribute, field);
                _defaultValue = CommandLineParser.DefaultValue(attribute, field);
                _elementType = ElementType(field);
                _flags = Flags(attribute, field);
                _field = field;
                _seenValue = false;
                _reporter = reporter;
                _isDefault = attribute is DefaultArgumentAttribute;

                if (IsCollection)
                {
                    _collectionValues = new ArrayList();
                }

                Debug.Assert(!string.IsNullOrEmpty(_longName));
                Debug.Assert(!_isDefault || !ExplicitShortName);
                Debug.Assert(!IsCollection || AllowMultiple, "Collection arguments must have allow multiple");
                Debug.Assert(!Unique || IsCollection, "Unique only applicable to collection arguments");
                Debug.Assert(IsValidElementType(Type) ||
                             IsCollectionType(Type));
                Debug.Assert((IsCollection && IsValidElementType(_elementType)) ||
                             (!IsCollection && _elementType == null));
                Debug.Assert(!(IsRequired && HasDefaultValue), "Required arguments cannot have default value");
                Debug.Assert(!HasDefaultValue || (_defaultValue.GetType() == field.FieldType), "Type of default value must match field type");
            }
예제 #46
0
 /// <summary>
 ///     Allows control of command line parsing.
 /// </summary>
 /// <param name="type"> Specifies the error checking to be done on the argument. </param>
 public ArgumentAttribute(ArgumentType type)
 {
     _type = type;
 }
예제 #47
0
 public ProcessArgumentEventArgs( ArgumentType type, string value )
     : this(type, value, "")
 {
 }
예제 #48
0
 public ProcessArgumentEventArgs( ArgumentType type, string value, string data )
 {
     this.type = type;
     this.value = value;
     this.data = data;
 }
예제 #49
0
 public ArgumentInfo(string argName)
 {
     kind = ArgumentType.Named;
     name = argName;
 }
예제 #50
0
 /// <summary>
 /// Creates a new CommandLineArgument instance
 /// </summary>
 /// <param name="name">The name of the argument</param>
 /// <param name="type">The argument type</param>
 /// <param name="shortDescription">The arguments short description</param>
 /// <param name="longDescription">The arguments long description</param>
 /// <param name="defaultValue">The default value of the argumen</param>
 /// <param name="aliases">A list of aliases for the command</param>
 /// <param name="values">A list of valid values for the command</param>
 /// <param name="deprecationMessage">A message indicating the reason for deprecation and any change suggestions</param>
 public CommandLineArgument(string name, ArgumentType type, string shortDescription, string longDescription, string defaultValue, string[] aliases, string[] values, string deprecationMessage)
     : this(name, type, shortDescription, longDescription, defaultValue, aliases, values)
 {
     m_deprecated = true;
     m_deprecationMessage = deprecationMessage;
 }
예제 #51
0
 /// <summary>
 /// Creates a new CommandLineArgument instance
 /// </summary>
 /// <param name="name">The name of the argument</param>
 /// <param name="type">The argument type</param>
 public CommandLineArgument(string name, ArgumentType type)
     : this(name)
 {
     m_type = type;
 }
예제 #52
0
 /// <summary>
 /// Allows control of command line parsing.
 /// </summary>
 /// <param name="type"> Specifies the error checking to be done on the argument. </param>
 public ArgumentAttribute(ArgumentType type)
 {
     this.type = type;
 }
예제 #53
0
 /// <summary>
 /// Creates a new CommandLineArgument instance
 /// </summary>
 /// <param name="name">The name of the argument</param>
 /// <param name="type">The argument type</param>
 /// <param name="shortDescription">The arguments short description</param>
 /// <param name="longDescription">The arguments long description</param>
 /// <param name="defaultValue">The default value of the argumen</param>
 public CommandLineArgument(string name, ArgumentType type, string shortDescription, string longDescription, string defaultValue)
     : this(name, type, shortDescription, longDescription)
 {
     m_defaultValue = defaultValue;
 }
 // ----------------------------------------------------------------------
 public NamedValueArgument( ArgumentType argumentType, string name, object defaultValue )
     : base(argumentType | ArgumentType.ContainsValue | ArgumentType.HasName, name, defaultValue)
 {
 }
예제 #55
0
 public ArgumentInstance(AbstractConstraint constraint, object value)
 {
     Constraint = constraint;
     Type = ArgumentType.ArgumentRef;
     ReturnValue = value;
 }
예제 #56
0
        private static Expression GetArgumentExpression(CallSignature signature, ArgumentType kind, ref int unusedCount, DynamicMetaObject/*!*/[]/*!*/ args) {
            int index = signature.IndexOf(kind);
            if (index != -1) {
                unusedCount--;
                return args[index].Expression;
            }

            return AstUtils.Constant(null);
        }
예제 #57
0
파일: Variable.cs 프로젝트: akostiv/pub
 public Variable(string name, ArgumentType type)
 {
     this.name = name;
     this.type = type;
 }
예제 #58
0
 public ArgumentInfo(ArgumentType argKind)
 {
     kind = argKind;
     name = null;
 }
예제 #59
0
 /// <summary>
 /// Indicates that this argument is the default argument.
 /// </summary>
 /// <param name="type"> Specifies the error checking to be done on the argument. </param>
 public DefaultArgumentAttribute(ArgumentType type)
     : base(type)
 {
 }
예제 #60
0
 // ----------------------------------------------------------------------
 public ValueArgument( ArgumentType argumentType )
     : base(argumentType | ArgumentType.ContainsValue, null, null)
 {
 }