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