public static IValue RunFile(string path, ScriptEnvironment environment = null) { var imports = new ImportResolver().ResolveImportsFromFile(path); var code = new ImportMerger().Merge(imports); ILexer finalLexer; if (code.Count > 1) { var lexers = new List <ILexer>(); foreach (var imported in code) { var reader = new ScriptReader(imported.Code, imported.Path, imported.LineOffset); var lexer = new ScriptLexer(reader, new CommonLexer(reader)); lexers.Add(lexer); } finalLexer = new MultifileLexer(lexers); } else { var imported = code.First(); var reader = new ScriptReader(imported.Code, imported.Path, imported.LineOffset); finalLexer = new ScriptLexer(reader, new CommonLexer(reader)); } var parser = new Parser(finalLexer); var ast = parser.Parse(); if (environment == null) { environment = new ScriptEnvironment(new OperationCodeFactory(), new ValueFactory()); environment.AddClassesDerivedFromClassInAssembly(typeof(Eilang)); environment.AddExportedFunctionsFromAssembly(typeof(Eilang)); environment.AddExportedModulesFromAssembly(typeof(Eilang)); } Compiler.Compile(environment, ast #if LOGGING , logger: Console.Out #endif ); var interpreter = new Interpreter(environment #if LOGGING , logger: Console.Out #endif ); return(interpreter.Interpret()); }
public void ResolveForFileReturnsExpectedImports() { var namespaces = CreateTestNamespaces(); var namespaceSettings = CreateNamespaceSettings(); var files = namespaces.GroupBy(x => x.OutputFilename).ToDictionary(g => g.Key, g => g.ToList()); var modelsNamespace = namespaces.Take(1).ToList(); Assume.That(modelsNamespace[0].TranslatedName, Is.EqualTo("Models")); var sut = new ImportResolver(files, namespaceSettings, defaultFilename); var actual = sut.ResolveForFile(modelsNamespace, "models.d.ts").ToList(); Assert.That(actual.Count, Is.EqualTo(1)); Assert.That(actual[0], Is.EqualTo("import { ViewModels } from './viewModels.d';")); }
///<summary> /// Determines the signature of the procedures, /// the locations and types of all the values in the program. ///</summary> public virtual void AnalyzeDataFlow() { var eventListener = services.RequireService <DecompilerEventListener>(); foreach (var program in project.Programs) { eventListener.ShowStatus("Performing interprocedural analysis."); var ir = new ImportResolver(project, program, eventListener); var dfa = new DataFlowAnalysis(program, ir, eventListener); dfa.UntangleProcedures(); dfa.BuildExpressionTrees(); host.WriteIntermediateCode(program, writer => { EmitProgram(program, dfa, writer); }); } eventListener.ShowStatus("Interprocedural analysis complete."); }
public void Impres_GlobalByName() { var proj = new Project { MetadataFiles = { new MetadataFile { ModuleName = "foo" } }, Programs = { program } }; var module = new ModuleDescriptor("foo") { GlobalsByName = { { "bar", new ImageSymbol { Name = "bar", Type = SymbolType.Data, DataType = new StructureType { Fields = { { 0, new Pointer(PrimitiveType.Char, 32), "name" }, { 4, PrimitiveType.Int32, "age" } } } } } } }; program.EnvironmentMetadata.Modules.Add(module.ModuleName, module); var impres = new ImportResolver(proj, program, new FakeDecompilerEventListener()); var dt = impres.ResolveImport("foo", "bar", platform); Assert.AreEqual("&bar", dt.ToString()); }
public void Impres_VtblFromMsMangledName() { var proj = new Project(); var impres = new ImportResolver(proj, program, new FakeDecompilerEventListener()); platform.Stub(p => p.ResolveImportByName(null, null)). IgnoreArguments().Return(null); SerializedType nullType = null; platform.Stub(p => p.DataTypeFromImportName("??_7Scope@@6B@")). Return(Tuple.Create("`vftable'", nullType, nullType)); var id = impres.ResolveImport("foo", "??_7Scope@@6B@", platform); Assert.AreEqual("`vftable'", id.ToString()); Assert.IsInstanceOf <UnknownType>(id.DataType); }
private void CheckImportResolver(string id, ImportResolverDelegate importResolver) { // Currently if no resolver is passed into AddText(), // the default fileResolver is used to resolve the imports. // default fileResolver require resource id should be fullPath, // so that it can resolve relative path based on this fullPath. // But we didn't check the id provided with AddText is fullPath or not. // So when id != fullPath, fileResolver won't work. if (importResolver == null) { var importPath = ImportResolver.NormalizePath(id); if (!Path.IsPathRooted(importPath)) { throw new Exception("[Error] id must be full path when importResolver is null"); } } }
public void Impres_LP32_weirdness() { var memText = new MemoryArea(Address.Ptr64(0x00123400), new byte[100]); var memGot = new MemoryArea(Address.Ptr64(0x00200000), new byte[100]); var wr = new LeImageWriter(memGot.Bytes); wr.WriteLeUInt32(0x00300000); wr.WriteLeUInt32(0x00300004); var arch = new FakeArchitecture64(); //var arch = new Mock<IProcessorArchitecture>(); //arch.Setup(a => a.Endianness).Returns(EndianServices.Little); //arch.Setup(a => a.Name).Returns("fakeArch"); //arch.Setup(a => a.PointerType).Returns(PrimitiveType.Ptr64); //arch.Setup(a => a.MakeAddressFromConstant( // It.IsAny<Constant>(), // It.IsAny<bool>())).Returns((Constant c, bool b) => // Address.Ptr64(c.ToUInt32())); var project = new Project(); var sc = new ServiceContainer(); var program = new Program { Architecture = arch, Platform = new DefaultPlatform(sc, arch), SegmentMap = new SegmentMap(memGot.BaseAddress, new ImageSegment(".text", memText, AccessMode.ReadExecute), new ImageSegment(".got", memGot, AccessMode.Read)), }; program.ImportReferences.Add( Address.Ptr32(0x00200000), new NamedImportReference( Address.Ptr32(0x00200000), null, "my_global_var", SymbolType.Data)); var impres = new ImportResolver(project, program, new FakeDecompilerEventListener()); var m = new ExpressionEmitter(); var proc = program.EnsureProcedure(program.Architecture, Address.Ptr64(0x00123000), "foo_proc"); var block = new Block(proc, "foo"); var stm = new Statement(0x00123400, new Store(m.Word64(0x00123400), Constant.Real32(1.0F)), block); var result = impres.ResolveToImportedValue(stm, Constant.Word32(0x00200000)); Assert.AreEqual("0x0000000000300000", result.ToString()); }
/// <summary> /// Load .lg files into template engine /// You can add one file, or mutlple file as once /// If you have multiple files referencing each other, make sure you add them all at once, /// otherwise static checking won't allow you to add it one by one. /// </summary> /// <param name="filePaths">Paths to .lg files.</param> /// <param name="importResolver">resolver to resolve LG import id to template text.</param> /// <returns>Teamplate engine with parsed files.</returns> public TemplateEngine AddFiles(IEnumerable <string> filePaths, ImportResolverDelegate importResolver = null) { var totalLGResources = new List <LGResource>(); foreach (var filePath in filePaths) { var fullPath = Path.GetFullPath(ImportResolver.NormalizePath(filePath)); var rootResource = LGParser.Parse(File.ReadAllText(fullPath), fullPath); var lgresources = rootResource.DiscoverDependencies(importResolver); totalLGResources.AddRange(lgresources); } // Remove duplicated lg files by id var deduplicatedLGResources = totalLGResources.GroupBy(x => x.Id).Select(x => x.First()).ToList(); Templates.AddRange(deduplicatedLGResources.SelectMany(x => x.Templates)); RunStaticCheck(Templates); return(this); }
public List <Diagnostic> CheckFiles(IEnumerable <string> filePaths, ImportResolverDelegate importResolver = null) { var result = new List <Diagnostic>(); var templates = new List <LGTemplate>(); var isParseSuccess = true; try { var totalLGResources = new List <LGResource>(); foreach (var filePath in filePaths) { // do not use ??=, it will cause issue in the C# < 8.0 importResolver = importResolver ?? ImportResolver.FileResolver; var fullPath = Path.GetFullPath(ImportResolver.NormalizePath(filePath)); var rootResource = LGParser.Parse(File.ReadAllText(fullPath), fullPath); var resources = rootResource.DiscoverDependencies(importResolver); totalLGResources.AddRange(resources); } var deduplicatedLGResources = totalLGResources.GroupBy(x => x.Id).Select(x => x.First()).ToList(); templates = deduplicatedLGResources.SelectMany(x => x.Templates).ToList(); } catch (LGException ex) { result.AddRange(ex.Diagnostics); isParseSuccess = false; } catch (Exception err) { result.Add(new Diagnostic(new Range(new Position(0, 0), new Position(0, 0)), err.Message)); isParseSuccess = false; } if (isParseSuccess) { result.AddRange(CheckTemplates(templates)); } return(result); }
protected Program RewriteFile( string relativePath, Address addrBase, Func <IServiceProvider, IProcessorArchitecture, IPlatform> mkPlatform) { sc = new ServiceContainer(); var config = new FakeDecompilerConfiguration(); var eventListener = new FakeDecompilerEventListener(); sc.AddService <IConfigurationService>(config); sc.AddService <IDecompiledFileService>(new FakeDecompiledFileService()); sc.AddService <DecompilerEventListener>(eventListener); sc.AddService <IFileSystemService>(new FileSystemServiceImpl()); var arch = new X86ArchitectureReal("x86-real-16"); ILoader ldr = new Loader(sc); var program = ldr.AssembleExecutable( FileUnitTester.MapTestPath(relativePath), new X86TextAssembler(sc, arch), addrBase); program.Platform = mkPlatform(sc, program.Architecture); var ep = ImageSymbol.Procedure(arch, program.SegmentMap.BaseAddress); var project = new Project { Programs = { program } }; var scan = new Scanner( program, new ImportResolver(project, program, eventListener), sc); scan.EnqueueImageSymbol(ep, true); scan.ScanImage(); var importResolver = new ImportResolver(project, program, eventListener); var dfa = new DataFlowAnalysis(program, importResolver, eventListener); dfa.AnalyzeProgram(); return(program); }
public void Impres_ProcedureByOrdinal() { var proj = new Project { MetadataFiles = { new MetadataFile { ModuleName = "foo" } }, Programs = { program } }; var module = new ModuleDescriptor("foo") { ServicesByOrdinal = { { 9, new SystemService { Name = "bar", Signature = new FunctionType() } } } }; program.EnvironmentMetadata.Modules.Add(module.ModuleName, module); var impres = new ImportResolver(proj, program, new FakeDecompilerEventListener()); var ep = impres.ResolveProcedure("foo", 9, platform); Assert.AreEqual("bar", ep.Name); }
public List <Diagnostic> CheckText(string content, string id = "", ImportResolverDelegate importResolver = null) { if (importResolver == null) { var importPath = ImportResolver.NormalizePath(id); if (!Path.IsPathRooted(importPath)) { throw new Exception("[Error] id must be full path when importResolver is null"); } } var result = new List <Diagnostic>(); var templates = new List <LGTemplate>(); var isParseSuccess = true; try { var rootResource = LGParser.Parse(content, id); var resources = rootResource.DiscoverDependencies(importResolver); templates = resources.SelectMany(x => x.Templates).ToList(); } catch (LGException ex) { result.AddRange(ex.Diagnostics); isParseSuccess = false; } catch (Exception err) { result.Add(new Diagnostic(new Range(new Position(0, 0), new Position(0, 0)), err.Message)); isParseSuccess = false; } if (isParseSuccess) { result.AddRange(CheckTemplates(templates)); } return(result); }
private string GetResourcePath(string filePath) { string resourcePath; if (Path.IsPathRooted(filePath)) { resourcePath = filePath; } else { var template = TemplateMap[CurrentTarget().TemplateName]; var sourcePath = ImportResolver.NormalizePath(template.Source); var baseFolder = Environment.CurrentDirectory; if (Path.IsPathRooted(sourcePath)) { baseFolder = Path.GetDirectoryName(sourcePath); } resourcePath = Path.GetFullPath(Path.Combine(baseFolder, filePath)); } return(resourcePath); }
private void RunTest(string sExp, Action <ProcedureBuilder> builder) { var pb = new ProcedureBuilder(this.pb.Program.Architecture); builder(pb); var proc = pb.Procedure; var dg = new DominatorGraph <Block>(proc.ControlGraph, proc.EntryBlock); var project = new Project { Programs = { this.pb.Program } }; var listener = new FakeDecompilerEventListener(); var importResolver = new ImportResolver( project, this.pb.Program, listener); var arch = new FakeArchitecture(); var platform = new FakePlatform(null, arch); // Register r1 is assumed to always be implicit when calling // another procedure. var implicitRegs = new HashSet <RegisterStorage> { arch.GetRegister(1) }; Debug.Print("GetRegister(1) {0}", arch.GetRegister(1)); this.pb.Program.Platform = platform; this.pb.Program.Platform = new FakePlatform(null, new FakeArchitecture()); this.pb.Program.SegmentMap = new SegmentMap( Address.Ptr32(0x0000), new ImageSegment( ".text", Address.Ptr32(0), 0x40000, AccessMode.ReadWriteExecute)); // Perform the initial transformation var ssa = new SsaTransform(programFlow, proc, importResolver, dg, implicitRegs); // Propagate values and simplify the results. // We hope the the sequence // esp = fp - 4 // mov [esp-4],eax // will become // esp_2 = fp - 4 // mov [fp - 8],eax var vp = new ValuePropagator(this.pb.Program.Architecture, ssa.SsaState, listener); vp.Transform(); ssa.RenameFrameAccesses = true; ssa.AddUseInstructions = true; ssa.Transform(); var writer = new StringWriter(); proc.Write(false, writer); var sActual = writer.ToString(); if (sActual != sExp) { Debug.Print(sActual); } Assert.AreEqual(sExp, sActual); ssa.SsaState.CheckUses(s => Assert.Fail(s)); }
//--- Constructors --- public ModelImportProcessor(Settings settings) : base(settings) { _importer = new ImportResolver(settings.SsmClient); }