public ExternalProcedure CreateExternalProcedure(IProcessorArchitecture arch)
		{
            if (Characteristics == null)
                return new ExternalProcedure(Name, Signature);
            else
                return new ExternalProcedure(Name, Signature, Characteristics);
		}

		public void Setup()
		{
			ssaIds = new SsaIdentifierCollection();
            mr = new MockRepository();
            arch = mr.Stub<IProcessorArchitecture>();
            importResolver = mr.Stub<IImportResolver>();
		}

 public ArgumentSerializer(ProcedureSerializer procSer, IProcessorArchitecture arch, Frame frame, string callingConvention)
 {
     this.procSer = procSer;
     this.arch = arch;
     this.frame = frame;
     this.convention = callingConvention;
 }

        //$TODO: http://www.delorie.com/djgpp/doc/rbinter/ix/29.html int 29 for console apps!
        //$TODO: http://msdn.microsoft.com/en-us/data/dn774154(v=vs.99).aspx

		public Win32Platform(IServiceProvider services, IProcessorArchitecture arch) : base(services, arch)
		{
            int3svc = new SystemService
            {
                SyscallInfo = new SyscallInfo
                {
                    Vector = 3,
                    RegisterValues = new RegValue[0],
                },
                Name = "int3",
                Signature = new ProcedureSignature(null, new Identifier[0]),
                Characteristics = new ProcedureCharacteristics(),
            };
            var frame = arch.CreateFrame();
            int29svc = new SystemService
            {
                SyscallInfo = new SyscallInfo
                {
                    Vector = 0x29,
                    RegisterValues = new RegValue[0]
                },
                Name = "__fastfail",
                Signature = new ProcedureSignature(
                    null,
                    frame.EnsureRegister(Registers.ecx)), //$bug what about win64?
                Characteristics = new ProcedureCharacteristics
                {
                    Terminates = true
                }
            };
        }

 public Program(SegmentMap segmentMap, IProcessorArchitecture arch, IPlatform platform) : this()
 {
     this.SegmentMap = segmentMap;
     this.ImageMap = segmentMap.CreateImageMap();
     this.Architecture = arch;
     this.Platform = platform;
 }

 private void Given_Architecture()
 {
     this.arch = mr.StrictMock<IProcessorArchitecture>();
     this.arch.Stub(a => a.Name).Return("testArch");
     this.arch.Stub(a => a.SaveUserOptions()).Return(null);
     this.cfgSvc.Stub(c => c.GetArchitecture("testArch")).Return(arch);
 }

		public void LoadRealmodeServices(IProcessorArchitecture arch)
		{
			string prefix = Environment.GetEnvironmentVariable("DECOMPILERROOTDIR") ?? ".";
			// TODO: extract runtime files ( like "realmodeintservices.xml") to their own directory ?
			string libPath = Path.Combine(prefix,"src","Environments","Msdos","realmodeintservices.xml");
			if (!File.Exists (libPath))
			{
                prefix = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
				libPath = Path.Combine(prefix,"realmodeintservices.xml");
				if (!File.Exists(libPath))
				{
					libPath = Path.Combine(Directory.GetCurrentDirectory() , "realmodeintservices.xml");
				}
			}

            SerializedLibrary lib;
            using (FileStream stm = new FileStream(libPath, FileMode.Open))
			{
                lib = SerializedLibrary.LoadFromStream(stm);
			}

            int i = 0;
			realModeServices = new SystemService[lib.Procedures.Count];
			foreach (SerializedService ssvc in lib.Procedures)
			{
				realModeServices[i++] = ssvc.Build(arch);
			}
		}

 public Program(LoadedImage image, ImageMap imageMap, IProcessorArchitecture arch, Platform platform) : this()
 {
     this.Image = image;
     this.ImageMap = imageMap;
     this.Architecture = arch;
     this.Platform = platform;
 }

 public void Setup()
 {
     this.mr = new MockRepository();
     this.sc = new ServiceContainer();
     loader = mr.Stub<ILoader>();
     arch = mr.StrictMock<IProcessorArchitecture>();
     Address dummy;
     arch.Stub(a => a.TryParseAddress(null, out dummy)).IgnoreArguments().WhenCalled(m =>
     {
         Address addr;
         var sAddr = (string)m.Arguments[0];
         var iColon = sAddr.IndexOf(':');
         if (iColon > 0)
         {
             addr = Address.SegPtr(
                 Convert.ToUInt16(sAddr.Remove(iColon)),
                 Convert.ToUInt16(sAddr.Substring(iColon+1)));
             m.ReturnValue = true;
         }
         else
         {
             m.ReturnValue = Address32.TryParse32((string)m.Arguments[0], out addr);
         }
         m.Arguments[1] = addr;
     }).Return(false);
 }

		public SystemService Build(IProcessorArchitecture arch)
		{
			SystemService svc = new SystemService();
			svc.Name = Name;
			svc.SyscallInfo = new SyscallInfo();
			svc.SyscallInfo.Vector = Convert.ToInt32(SyscallInfo.Vector, 16);
			if (SyscallInfo.RegisterValues != null)
			{
				svc.SyscallInfo.RegisterValues = new RegValue[SyscallInfo.RegisterValues.Length];
				for (int i = 0; i < SyscallInfo.RegisterValues.Length; ++i)
				{
                    svc.SyscallInfo.RegisterValues[i] = new RegValue
                    {
                        Register = arch.GetRegister(SyscallInfo.RegisterValues[i].Register),
                        Value = Convert.ToInt32(SyscallInfo.RegisterValues[i].Value, 16),
                    };
				}
			}
			else
			{
				svc.SyscallInfo.RegisterValues = new RegValue[0];
			}
            TypeLibraryLoader loader = new TypeLibraryLoader(arch, true);
			ProcedureSerializer sser = arch.CreateProcedureSerializer(loader, "stdapi");
            svc.Signature = sser.Deserialize(Signature, arch.CreateFrame());
			svc.Characteristics = Characteristics != null ? Characteristics : DefaultProcedureCharacteristics.Instance;
			return svc;
		}

 public Win_x86_64_Platform(IServiceProvider sp, IProcessorArchitecture arch)
     : base(sp, arch, "win64")
 {
     int3svc = new SystemService
     {
         SyscallInfo = new SyscallInfo
         {
             Vector = 3,
             RegisterValues = new RegValue[0],
         },
         Name = "int3",
         Signature = FunctionType.Action(new Identifier[0]),
         Characteristics = new ProcedureCharacteristics(),
     };
     int29svc = new SystemService
     {
         SyscallInfo = new SyscallInfo
         {
             Vector = 0x29,
             RegisterValues = new RegValue[0]
         },
         Name = "__fastfail",
         Signature = FunctionType.Action(
                     new Identifier("ecx", PrimitiveType.Word32, Registers.ecx)),
         Characteristics = new ProcedureCharacteristics
         {
             Terminates = true
         }
     };
 }

 private void Given_ArchitectureStub()
 {
     arch = mr.DynamicMock<IProcessorArchitecture>();
     var procSer = mr.StrictMock<ProcedureSerializer>(null, null, null);
     arch.Stub(a => a.CreateProcedureSerializer(null, null)).IgnoreArguments().Return(procSer);
     procSer.Stub(p => p.Deserialize(null, null)).IgnoreArguments().Return(new ProcedureSignature());
 }

 public Arm32ProcedureSerializer(
     IProcessorArchitecture arch,
     ISerializedTypeVisitor<DataType> typeLoader, 
     string defaultConvention) 
     : base(arch, typeLoader, defaultConvention)
 {
 }

 public void Setup()
 {
     mr = new MockRepository();
     program = new Program();
     proc = new Procedure("testProc", new Frame(PrimitiveType.Word32));
     block = proc.AddBlock("l00100000");
     trace = new RtlTrace(0x00100000);
     r0 = new Identifier("r0", PrimitiveType.Word32, new RegisterStorage("r0", 0, 0, PrimitiveType.Word32));
     r1 = new Identifier("r1", PrimitiveType.Word32, new RegisterStorage("r1", 1, 0, PrimitiveType.Word32));
     r2 = new Identifier("r2", PrimitiveType.Word32, new RegisterStorage("r2", 2, 0, PrimitiveType.Word32));
     sp = new Identifier("sp", PrimitiveType.Word32, new RegisterStorage("sp", 15, 0, PrimitiveType.Word32));
     grf = proc.Frame.EnsureFlagGroup(Registers.eflags, 3, "SCZ", PrimitiveType.Byte);
     var sc = new ServiceContainer();
     var listener = mr.Stub<DecompilerEventListener>();
     scanner = mr.StrictMock<IScanner>();
     arch = mr.Stub<IProcessorArchitecture>();
     program.Architecture = arch;
     program.SegmentMap = new SegmentMap(
         Address.Ptr32(0x00100000),
         new ImageSegment(
             ".text",
             new MemoryArea(Address.Ptr32(0x00100000), new byte[0x20000]),
             AccessMode.ReadExecute));
     arch.Replay();
     program.Platform = new DefaultPlatform(null, arch);
     arch.BackToRecord();
     arch.Stub(s => s.StackRegister).Return((RegisterStorage)sp.Storage);
     arch.Stub(s => s.PointerType).Return(PrimitiveType.Pointer32);
     scanner.Stub(s => s.Services).Return(sc);
     sc.AddService<DecompilerEventListener>(listener);
 }

 public PowerPcProcedureSerializer(
     IProcessorArchitecture  arch,
     ISerializedTypeVisitor<DataType> typeLoader,
     string defaultCc)
     : base(arch, typeLoader, defaultCc)
 {
     this.arch = arch;
 }

 public ElfObjectLinker(ElfLoader loader, IProcessorArchitecture arch, byte[] rawImage)
 {
     if (rawImage == null)
         throw new ArgumentNullException("rawImage");
     this.loader = loader;
     this.arch = arch;
     this.rawImage = rawImage;
 }

 public IAssumedRegisterValuesDialog CreateAssumedRegisterValuesDialog(
     IProcessorArchitecture arch)
 {
     return new AssumedRegisterValuesDialog
     {
         Architecture = arch,
     };
 }

 private void Given_i386_Architecture()
 {
     this.arch_386 = mr.StrictMock<IProcessorArchitecture>();
     arch_386.Stub(a => a.CreateFrame()).Return(new Frame(PrimitiveType.Pointer32));
     arch_386.Stub(a => a.WordWidth).Return(PrimitiveType.Word32);
     var state = mr.Stub<ProcessorState>();
     arch_386.Stub(a => a.CreateProcessorState()).Return(state);
 }

 public Platform Load(IServiceProvider services, IProcessorArchitecture arch)
 {
     var type = Type.GetType(TypeName);
     if (type == null)
         throw new TypeLoadException(
             string.Format("Unable to load {0} environment.", Description));
     return (Platform) Activator.CreateInstance(type, services, arch);
 }

 public RtlStatementStream(uint address, Frame frame)
 {
     this.linAddress = address;
     this.arch = new FakeArchitecture();
     this.frame = frame;
     this.stms = new List<RtlInstructionCluster>();
 }