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" );
     }
 }

        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 ) );
        }

        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);
        }

        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);
        }

 /// <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;
 }

 public ProcessArgumentEventArgs( ArgumentType type, string value )
     : this(type, value, "")
 {
 }

 /// <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;
 }

 /// <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;
 }

 public ArgumentInstance(AbstractConstraint constraint, object value)
 {
     Constraint = constraint;
     Type = ArgumentType.ArgumentRef;
     ReturnValue = value;
 }

 // ----------------------------------------------------------------------
 public ValueArgument( ArgumentType argumentType )
     : base(argumentType | ArgumentType.ContainsValue, null, null)
 {
 }

 // ----------------------------------------------------------------------
 public NamedValueArgument( ArgumentType argumentType, string name, object defaultValue )
     : base(argumentType | ArgumentType.ContainsValue | ArgumentType.HasName, name, defaultValue)
 {
 }

 /// <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)
 {
 }

 public Variable(string name, ArgumentType type)
 {
     this.name = name;
     this.type = type;
 }

 public ClassifiedArgument(ArgumentType argumentType, CommandParameterInfo parameterInfo, string value)
 {
     this.ArgumentType = argumentType;
     this.ParameterInfo = parameterInfo;
     this.Value = value;
 }

 public ArgumentInfo(string argName)
 {
     kind = ArgumentType.Named;
     name = argName;
 }

		// ----------------------------------------------------------------------
		protected Argument( ArgumentType argumentType, string name, object defaultValue )
		{
			this.name = name;
			this.argumentType = argumentType;
			this.defaultValue = defaultValue;
		} // Argument

 /// <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)
 {
 }

            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");
            }