protected override IEnumerable<string> Format(Argument[] arguments)
        {
            var list = new List<string>();
            string deferred = null;
            foreach (var argument in arguments)
            {
                if (deferred != null)
                {
                    deferred += ",";
                }

                foreach (var line in this.Format(argument))
                {
                    if (deferred != null)
                    {
                        list.Add(deferred);
                    }

                    deferred = line;
                }
            }

            if (deferred != null)
            {
                list.Add(deferred);
            }

            return list;
        }

		public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
		{
			if (input.Arguments.Count > 0)
			{
				var arguments = new Argument[input.Arguments.Count];

				for (int i = 0; i < input.Arguments.Count; i++)
				{
					arguments[i] = new Argument
					               	{
					              		Name = input.Arguments.ParameterName(i),
					              		Value = input.Arguments[i]
					              	};
				}

				_tape.RecordRequest(arguments, input.MethodBase.ReflectedType, input.MethodBase.Name);
			}

			Console.WriteLine("> Intercepting " + input.MethodBase.Name);
			Console.WriteLine("> Intercepting " + input.MethodBase.ReflectedType);

			IMethodReturn methodReturn = getNext()(input, getNext);

			Console.WriteLine("> Intercepted return value: " + methodReturn.ReturnValue.GetType().Name);

			if (methodReturn.ReturnValue != null)
			{
				_tape.RecordResponse(methodReturn.ReturnValue, input.MethodBase.ReflectedType, input.MethodBase.Name);
			}

			return methodReturn;
		}

 private IEnumerable<string> GetResult(string text)
 {
     var mock = new Mock<IRunner>();
     mock.Setup(o => o.WorkingDirectory).Returns(Path.Combine(Environment.CurrentDirectory, "Test"));
     _argument = ArgumentFactory.Create(mock.Object, text);
     return _argument.Complete();
 }

	private void concat(StringBuilder buf, Argument arg) {
		Iterator<Token>	it = arg.iterator();
		while (it.hasNext()) {
			Token	tok = it.next();
			buf.append(tok.getText());
		}
	}

        public void IArgumentInfo_DefaultValue_returns_same_as_typed_property()
        {
            var arg = new Argument<string>(_parser, "short", "long", "foo", false);
            arg.DefaultValue = "timmeh!";

            Assert.Equal("timmeh!", ((IArgument)arg).DefaultValue);
        }

 public Command(Argument[] arguments, string description, string group, string name)
 {
     Arguments = arguments;
     Description = description;
     Group = group;
     Name = name;
 }

 public static SCode Make(Primitive2 rator, Argument rand0, SCode rand1)
 {
     return
         (rand0 is Argument0) ? PrimitiveIsCharEqA0.Make (rator, (Argument0) rand0, rand1)
         : (rand0 is Argument1) ? PrimitiveIsCharEqA1.Make (rator, (Argument1) rand0, rand1)
         : Unimplemented ();
 }

 public object GetValue(Argument arg, int size)
 {
     switch (Tag)
     {
     case TypeTag.Boolean:
     case TypeTag.Int8:
     case TypeTag.UInt8:
     case TypeTag.Int16:
     case TypeTag.UInt16:
     case TypeTag.Int32:
     case TypeTag.UInt32:
     case TypeTag.Int64:
     case TypeTag.UInt64:
     case TypeTag.Int:
     case TypeTag.UInt:
     case TypeTag.Long:
     case TypeTag.ULong:
     case TypeTag.SSize:
     case TypeTag.Size:
     case TypeTag.Float:
     case TypeTag.Double:
         return typeof(Argument).GetField(Tag.ToString()).GetValue(arg);
     case TypeTag.Utf8:
         return GObject.Marshaller.Utf8PtrToString((IntPtr) arg.Pointer);
     default:
         return null;
     }
 }

        public void exception_is_thrown_when_argments_are_not_valid()
        {
            _parser.IsValid = false;

            var arg = new Argument<int>(_parser, "shortName", "longName", "description", true);
            int value;
            Assert.Throws<InvalidOperationException>(() => value = arg.Value);
        }

 public void Value_returns_default_value_when_IsMissing()
 {
     _parser.IsValid = true;
     var arg = new Argument<string>(_parser, "short", "long", "foo", false);
     arg.IsMissing = true;
     arg.DefaultValue = "gobbles!";
     Assert.Equal("gobbles!", arg.Value);
 }

 /// <summary>
 /// Constructor that forms the info from the argument's metadata.
 /// </summary>
 /// <param name="setAttribute">Argument set attribute.</param>
 /// <param name="arg">Argument metadata.</param>
 public ArgumentUsageInfo(ArgumentSetAttribute setAttribute, Argument arg)
 {
     Syntax = arg.GetSyntaxHelp(setAttribute);
     Description = arg.Attribute.HelpText;
     Required = arg.IsRequired;
     ShortName = arg.ShortName;
     DefaultValue = TryGetDefaultValueString(setAttribute, arg);
 }

 protected Action(Argument argument, IActionContainer container=null)
 {
     Argument = argument;
     Container = container;
     OptionStrings = new List<string>(Argument.OptionStrings ?? new string[] {});
     Destination = Argument.Destination;
     IsRequired = Argument.IsRequired;
 }

 public static SCode Make(Primitive2 rator, Argument rand0, SCode rand1)
 {
     return
         (rand0 is Argument0) ? PrimitiveIsObjectEqA0.Make (rator, (Argument0) rand0, rand1)
         : (rand0 is Argument1) ? PrimitiveIsObjectEqA1.Make (rator, (Argument1) rand0, rand1)
         : (rand1 is LexicalVariable) ? Unimplemented()
         : (rand1 is Quotation) ? PrimitiveIsObjectEqAQ.Make (rator, rand0, (Quotation) rand1)
         : new PrimitiveIsObjectEqA (rator, rand0, rand1);
 }

        protected IEnumerable<string> Format(Argument argument)
        {
            var type = argument.GetType();

            if (type == typeof(NamedArgument)) return Format((NamedArgument)argument);
            if (type == typeof(PositionalArgument)) return Format((PositionalArgument)argument);

            throw new ArgumentException("Unhandled type " + type.FullName, nameof(argument));
        }

 internal void SetArgumentValue(IScriptExtent extent, object value)
 {
     if (this._argument == null)
     {
         this._argument = new Argument();
     }
     this._argument.value = value;
     this._argument.extent = extent;
 }

 public ExecutionStackItem(Argument arg)
 {
     _variable = new VariableItem();
     _variable.Value = arg.Value;
     if(arg.Value.Type == HVMType.Variable)
     {
         _variable.Name = arg.Value.StringValue;
     }
 }

        /// <summary>
        ///     Creates a new command line argument parser.
        /// </summary>
        /// <param name="argumentSpecification"> The type of object to parse. </param>
        /// <param name="reporter"> The destination for parse errors. </param>
        private Parser(Type argumentSpecification, ErrorReporter reporter)
        {
            this.reporter = reporter;
            this.reporter += Log.Error;
            this.arguments = new ArrayList();
            this.argumentMap = new Hashtable();

            foreach (FieldInfo field in argumentSpecification.GetFields())
            {
                if (!field.IsStatic && !field.IsInitOnly && !field.IsLiteral)
                {
                    ArgumentAttribute attribute = GetAttribute(field);
                    if (attribute is DefaultArgumentAttribute)
                    {
                        Debug.Assert(this.defaultArgument == null);
                        this.defaultArgument = new Argument(attribute, field, reporter);
                    }
                    else
                    {
                        this.arguments.Add(new Argument(attribute, field, reporter));
                    }
                }
            }

            // add explicit names to map
            foreach (Argument argument in this.arguments)
            {
                Debug.Assert(!this.argumentMap.ContainsKey(argument.LongName));
                this.argumentMap[argument.LongName] = argument;
                if (argument.ExplicitShortName)
                {
                    if (!string.IsNullOrEmpty(argument.ShortName))
                    {
                        Debug.Assert(!this.argumentMap.ContainsKey(argument.ShortName));
                        this.argumentMap[argument.ShortName] = argument;
                    }
                    else
                    {
                        argument.ClearShortName();
                    }
                }
            }

            // add implicit names which don't collide to map
            foreach (Argument argument in this.arguments)
            {
                if (!argument.ExplicitShortName)
                {
                    if (!string.IsNullOrEmpty(argument.ShortName) &&
                        !this.argumentMap.ContainsKey(argument.ShortName))
                        this.argumentMap[argument.ShortName] = argument;
                    else
                        argument.ClearShortName();
                }
            }
        }

  static void Process(Argument cmdline){
    if(cmdline.IsTest){
      Trans.Test(cmdline);
      return;
    }

    // 各ファイルに対する処理
    System.Text.StringBuilder bcontent=new System.Text.StringBuilder();
    foreach(string file in cmdline.FileNames){
      string content1=System.IO.File.ReadAllText(file,System.Text.Encoding.UTF8);
      if(cmdline.Verbose)
        cmdline.WriteLine("gzjs: read from {0}.",file);

      content1=Trans.ProcessSource(content1,cmdline);
      if(cmdline.TokenReplacing)
        content1=Trans.GenerateTokenReplacing2(content1,cmdline);
      bcontent.Append(content1);
    }

    // 全体に対する処理
    string content=bcontent.ToString();
    if(cmdline.IsSfx85)
      content=Trans.CreateSfx85(content);
    else if(cmdline.IsSfx)
      content=Trans.CreateSfx(content);

    content=content.Replace("\r\n","\n");

    // 書込
    if(cmdline.IsGzipCompress){
      string gzfile=cmdline.OutputFile;
      if(cmdline.OutputFile=="-"){
        using(System.IO.Stream stdout=System.Console.OpenStandardOutput())
          IO.SaveAsGzipFile(stdout,content);
      }else
        IO.SaveAsGzipFile(gzfile,content);

      // <gzip.exe を使う場合>
      // string tempfile=System.IO.Path.Combine(IO.path_temp,System.IO.Path.GetFileName(cmdline.OutputFile));
      // writeFile(tempfile,content);
      // string gzfile=cmdline.OutputFile+".gz";
      // IO.gzip(tempfile,gzfile,false);
      // </gzip>

      if(cmdline.Verbose)
        cmdline.WriteLine("gzjs: wrote to {0}.",gzfile);
    }else{
      string outfile=cmdline.OutputFile;
      if(outfile=="-")
        System.Console.Write(content);
      else
        writeFile(outfile,content);
      if(cmdline.Verbose)
        cmdline.WriteLine("gzjs: wrote to {0}.",outfile);
    }
  }

 private object evaluateArgument(Argument argument) {
     if (argument.style == Argument.Style.Constant) {
         return argument.value;
     } else if (argument.style == Argument.Style.Parameter) {
         return ((Parameter)argument.value).value;
     } else if (argument.style == Argument.Style.Filter) {
         return evaluateFilter((Method)argument.value);
     }
     return null;
 }

 public Parser(Type argumentSpecification, ErrorReporter reporter)
 {
     this.reporter = reporter;
     arguments = new ArrayList();
     argumentMap = new Hashtable();
     FieldInfo[] fields = argumentSpecification.GetFields();
     for (int i = 0; i < fields.Length; i++)
     {
         FieldInfo field = fields[i];
         if (!field.IsStatic && !field.IsInitOnly && !field.IsLiteral)
         {
             ArgumentAttribute attribute = GetAttribute(field);
             if (attribute is DefaultArgumentAttribute)
             {
                 Debug.Assert(defaultArgument == null);
                 defaultArgument = new Argument(attribute, field, reporter);
             }
             else
             {
                 arguments.Add(new Argument(attribute, field, reporter));
             }
         }
     }
     foreach (Argument argument in arguments)
     {
         Debug.Assert(!argumentMap.ContainsKey(argument.LongName));
         argumentMap[argument.LongName] = argument;
         if (argument.ExplicitShortName)
         {
             if (argument.ShortName != null && argument.ShortName.Length > 0)
             {
                 Debug.Assert(!argumentMap.ContainsKey(argument.ShortName));
                 argumentMap[argument.ShortName] = argument;
             }
             else
             {
                 argument.ClearShortName();
             }
         }
     }
     foreach (Argument argument in arguments)
     {
         if (!argument.ExplicitShortName)
         {
             if (argument.ShortName != null && argument.ShortName.Length > 0 && !argumentMap.ContainsKey(argument.ShortName))
             {
                 argumentMap[argument.ShortName] = argument;
             }
             else
             {
                 argument.ClearShortName();
             }
         }
     }
 }