public ConditionCodeEliminator(SsaState ssa, IPlatform arch)
		{
            this.ssa=ssa;
			this.ssaIds = ssa.Identifiers;
            this.platform = arch;
            this.m = new ExpressionEmitter();
		}

  public XmlConverter(TextReader rdr, XmlWriter writer, IPlatform platform)
  {
      this.rdr = rdr;
      this.writer = writer;
      this.platform = platform;
      this.parserState = new ParserState();
 }

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

 public TypeLibrary Load(IPlatform platform, string module, TypeLibrary dstLib)
 {
     this.platform = platform;
     this.tlLoader = new TypeLibraryDeserializer(platform, true, dstLib);
     this.moduleName = module;
     tlLoader.SetModuleName(module);
     for (;;)
     {
         var tok = Peek();
         if (tok.Type == TokenType.EOF)
             break;
         if (PeekAndDiscard(TokenType.NL))
             continue;
         var line =  ParseLine();
         if (line != null)
         {
             if (line.Item1.HasValue)
             {
                 tlLoader.LoadService(line.Item1.Value, line.Item2);
             }
             else
             {
                 tlLoader.LoadService(line.Item2.Name, line.Item2);
             }
         }
     }
     return dstLib;
 }

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

        public ExternalProcedure ResolveProcedure(string moduleName, string importName, IPlatform platform)
        {
            foreach (var program in project.Programs)
            {
                ModuleDescriptor mod;
                if (!program.Metadata.Modules.TryGetValue(moduleName, out mod))
                    continue;

                SystemService svc;
                if (mod.ServicesByName.TryGetValue(importName, out svc))
                {
                    return new ExternalProcedure(svc.Name, svc.Signature, svc.Characteristics);
                }
            }

            foreach (var program in project.Programs)
            {
                ProcedureSignature sig;
                if (program.Metadata.Signatures.TryGetValue(importName, out sig))
                {
                    return new ExternalProcedure(importName, sig);
                }
            }

            return platform.LookupProcedureByName(moduleName, importName);
        }

        // ctor

        /// <summary>
        /// Initializes a new instance of the <see cref="DataManager"/> class.
        /// </summary>
        /// <param name="platform">The platform.</param>
        public DataManager(IPlatform platform)
        {
            _platform = platform;
            AppService = new AppService();

            _current = this;
        }

        public IPlatform CreatePlatform()
        {
            if (platform != null)
                return platform;

            platform = mr.Stub<IPlatform>();

            platform.Stub(p => p.Name).Return("TestPlatform");
            platform.Stub(p => p.PointerType).Return(PrimitiveType.Pointer32);
            platform.Stub(p => p.GetByteSizeFromCBasicType(CBasicType.Char)).Return(1);
            platform.Stub(p => p.GetByteSizeFromCBasicType(CBasicType.Short)).Return(2);
            platform.Stub(p => p.GetByteSizeFromCBasicType(CBasicType.Int)).Return(4);
            platform.Stub(p => p.GetByteSizeFromCBasicType(CBasicType.Long)).Return(4);
            platform.Stub(p => p.GetByteSizeFromCBasicType(CBasicType.LongLong)).Return(8);
            platform.Stub(p => p.GetByteSizeFromCBasicType(CBasicType.Float)).Return(4);
            platform.Stub(p => p.GetByteSizeFromCBasicType(CBasicType.Double)).Return(8);
            platform.Stub(p => p.GetByteSizeFromCBasicType(CBasicType.LongDouble)).Return(8);
            platform.Stub(p => p.GetByteSizeFromCBasicType(CBasicType.Int64)).Return(8);
            platform.Stub(p => p.CreateMetadata()).Do(new Func<TypeLibrary>(() => this.platformMetadata.Clone()));
            var arch = new X86ArchitectureFlat32();
            platform.Stub(p => p.Architecture).Return(arch);
            platform.Stub(p => p.DefaultCallingConvention).Return("__cdecl");

            platform.Stub(s => s.CreateProcedureSerializer(null, null)).IgnoreArguments().Do(
                new Func<ISerializedTypeVisitor<DataType>, string, ProcedureSerializer>((tlDeser, dc) =>
                    new X86ProcedureSerializer(arch, tlDeser, dc)
                )
            );
            platform.Stub(p => p.SaveUserOptions()).Return(null);

            platform.Replay();
            return platform;
        }

        public ExternalProcedure ResolveProcedure(string moduleName, string importName, IPlatform platform)
        {
            if (!string.IsNullOrEmpty(moduleName))
            {
                foreach (var program in project.Programs)
                {
                    ModuleDescriptor mod;
                    if (!program.EnvironmentMetadata.Modules.TryGetValue(moduleName, out mod))
                        continue;

                    SystemService svc;
                    if (mod.ServicesByName.TryGetValue(importName, out svc))
                    {
                        return new ExternalProcedure(svc.Name, svc.Signature, svc.Characteristics);
                    }
                }
            }

            foreach (var program in project.Programs)
            {
                FunctionType sig;
                if (program.EnvironmentMetadata.Signatures.TryGetValue(importName, out sig))
                {
                    var chr = platform.LookupCharacteristicsByName(importName);
                    if (chr != null)
                        return new ExternalProcedure(importName, sig, chr);
                    else
                        return new ExternalProcedure(importName, sig);
                }
            }

            return platform.LookupProcedureByName(moduleName, importName);
        }

		public SystemService Build(IPlatform platform, TypeLibrary library)
		{
			SystemService svc = new SystemService();
			svc.Name = Name;
			svc.SyscallInfo = new SyscallInfo();
            svc.SyscallInfo.Vector = SyscallInfo != null
                ? Convert.ToInt32(SyscallInfo.Vector, 16)
                : this.Ordinal;
            if (SyscallInfo != null)
            {
                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 = platform.Architecture.GetRegister(SyscallInfo.RegisterValues[i].Register),
                            Value = Convert.ToInt32(SyscallInfo.RegisterValues[i].Value, 16),
                        };
                    }
                }
            }
			if (svc.SyscallInfo.RegisterValues == null)
			{
				svc.SyscallInfo.RegisterValues = new RegValue[0];
			}
            TypeLibraryDeserializer loader = new TypeLibraryDeserializer(platform, true, library);
			var sser = platform.CreateProcedureSerializer(loader, "stdapi");
            svc.Signature = sser.Deserialize(Signature, platform.Architecture.CreateFrame());
			svc.Characteristics = Characteristics != null ? Characteristics : DefaultProcedureCharacteristics.Instance;
			return svc;
		}

 public void ProcessDeclaration(Decl declaration, IPlatform platform, TypeLibraryDeserializer tldser, SymbolTable symbolTable)
 {
     var types = symbolTable.AddDeclaration(declaration);
     var type = types[0];
     int? vectorOffset = GetVectorOffset(declaration);
     if (vectorOffset.HasValue)
     {
         var ntde = new NamedDataTypeExtractor(platform, declaration.decl_specs, symbolTable);
         foreach (var declarator in declaration.init_declarator_list)
         {
             var nt = ntde.GetNameAndType(declarator.Declarator);
             var ssig = (SerializedSignature)nt.DataType;
             if (ssig.ReturnValue != null)
             {
                 ssig.ReturnValue.Kind = ntde.GetArgumentKindFromAttributes(
                     "returns", declaration.attribute_list);
             }
             var sser = platform.CreateProcedureSerializer(tldser, platform.DefaultCallingConvention);
             var sig = sser.Deserialize(ssig, platform.Architecture.CreateFrame());
             SystemServices.Add(
                 vectorOffset.Value,
                 new SystemService
                 {
                     Name = nt.Name,
                     SyscallInfo = new SyscallInfo
                     {
                         Vector = vectorOffset.Value,
                     },
                     Signature = sig,
                 });
         }
     }
 }

 private static Task<MobileServiceUser> LoginFacebookAsync(IPlatform mobileClient)
 {
     // use server flow if the service URL has been customized
     return Settings.IsDefaultServiceUrl() ?
         mobileClient.LoginFacebookAsync() :
         mobileClient.LoginAsync(MobileServiceAuthenticationProvider.Facebook);
 }

        public PlatformKernel(IPlatform platform)
        {
            var runtimeModule = GetRuntimeModule(platform);
            Load(runtimeModule);

            AddBindingResolver<IDisplay>(DisplayBindingResolver);
        }

		public DataTypeBuilder(TypeFactory factory, ITypeStore store, IPlatform platform)
		{
			this.store = store;
			this.factory = factory;
			this.unifier = new DataTypeBuilderUnifier(factory, store);
            this.platform = platform;
		}

        public Sound(IPlatform platform, SoundSettings soundSettings)
        {
            soundEngine = platform.CreateSound(soundSettings.Device);

            if (soundSettings.Mute)
                MuteAudio();
        }

        private void BuildTest(Address addrBase, IPlatform platform , Action<X86Assembler> asmProg)
        {
            var sc = new ServiceContainer();
            sc.AddService<DecompilerEventListener>(new FakeDecompilerEventListener());
            sc.AddService<DecompilerHost>(new FakeDecompilerHost());
            sc.AddService<IFileSystemService>(new FileSystemServiceImpl());
            var entryPoints = new List<EntryPoint>();
            var asm = new X86Assembler(sc, platform, addrBase, entryPoints);
            asmProg(asm);

            var lr = asm.GetImage();
            program = new Program(
                lr.Image,
                lr.ImageMap,
                arch,
                platform);
            var project = new Project { Programs = { program } };
            scanner = new Scanner(
                program,
                new Dictionary<Address, ProcedureSignature>(),
                new ImportResolver(project),
                sc);
            scanner.EnqueueEntryPoint(new EntryPoint(addrBase, arch.CreateProcessorState()));
            scanner.ScanImage();
        }

 private void Given_Platform(IPlatform platform)
 {
     this.oe = mr.Stub<OperatingEnvironment>();
     this.platform = platform;
     this.cfgSvc.Stub(c => c.GetEnvironment("testOS")).Return(oe);
     oe.Stub(e => e.Load(sc, null)).IgnoreArguments().Return(platform);
 }

 private void Given_TestOS()
 {
     this.oe = mr.Stub<OperatingEnvironment>();
     this.platform = mr.Stub<IPlatform>();
     this.cfgSvc.Stub(c => c.GetEnvironment("testOS")).Return(oe);
     oe.Stub(e => e.Load(sc, null)).IgnoreArguments().Return(platform);
     this.platform.Stub(p => p.CreateMetadata()).Return(new TypeLibrary());
 }

 public static void Initialize(IPlatform platform)
 {
     if( null != Kernel )
     {
         throw new ArgumentException("Kernel has already been initialized");
     }
     Kernel = new PlatformKernel(platform);
 }

 public override TypeLibrary Load(IPlatform platform, TypeLibrary dstLib)
 {
     var ser = SerializedLibrary.CreateSerializer();
     var slib = (SerializedLibrary) ser.Deserialize(stream);
     var tldser = new TypeLibraryDeserializer(platform, true, dstLib);
     var tlib = tldser.Load(slib);
     return tlib;
 }