public void SetUp() { snippetGenerator = new SnippetGenerator(true); var loader = new CecilLoader(); loader.IncludeInternalMembers = true; myLib = loader.LoadAssemblyFile(typeof(SnippetGenerationTests).Assembly.Location); mscorlib = loader.LoadAssemblyFile(typeof(object).Assembly.Location); compilation = new SimpleCompilation(myLib, mscorlib); }
public CSharpCompletion() { projectContent = new CSharpProjectContent(); var assemblies = new List<Assembly> { typeof(object).Assembly, // mscorlib typeof(Uri).Assembly, // System.dll typeof(Enumerable).Assembly, // System.Core.dll // typeof(System.Xml.XmlDocument).Assembly, // System.Xml.dll // typeof(System.Drawing.Bitmap).Assembly, // System.Drawing.dll // typeof(Form).Assembly, // System.Windows.Forms.dll // typeof(ICSharpCode.NRefactory.TypeSystem.IProjectContent).Assembly, }; var unresolvedAssemblies = new IUnresolvedAssembly[assemblies.Count]; Stopwatch total = Stopwatch.StartNew(); Parallel.For( 0, assemblies.Count, delegate(int i) { var loader = new CecilLoader(); var path = assemblies[i].Location; loader.DocumentationProvider = GetXmlDocumentation(assemblies[i].Location); unresolvedAssemblies[i] = loader.LoadAssemblyFile(assemblies[i].Location); }); Debug.WriteLine("Init project content, loading base assemblies: " + total.Elapsed); projectContent = projectContent.AddAssemblyReferences((IEnumerable<IUnresolvedAssembly>)unresolvedAssemblies); }
public CSharpCompletion() { projectContent = new CSharpProjectContent(); var assemblies = new List<Assembly> { typeof(object).Assembly, // mscorlib typeof(Uri).Assembly, // System.dll typeof(Enumerable).Assembly, // System.Core.dll typeof(System.Xml.XmlDocument).Assembly, // System.Xml.dll typeof(Sandbox.Common.ObjectBuilders.MyObjectBuilder_AdvancedDoor).Assembly, // SpaceEngineers.ObjectBuilders.dll typeof(SpaceEngineers.Game.ModAPI.IMyButtonPanel).Assembly, // SpaceEngineers.Game.dll typeof(Sandbox.MySandboxGame).Assembly, // Sandbox.Game.dll typeof(Sandbox.ModAPI.MyAPIGateway).Assembly, // Sandbox.Common.dll typeof(Sandbox.Graphics.GUI.MyGuiSandbox).Assembly, // Sandbox.Graphics.dll typeof(VRage.MyModelData).Assembly, // VRage.dll typeof(VRage.Exceptions).Assembly, // VRage.Library.dll typeof(VRageMath.MathHelper).Assembly, // VRage.Math typeof(VRage.Game.ObjectBuilders.MyObjectBuilder_EntityStat).Assembly, //VRage.Game }; var unresolvedAssemblies = new IUnresolvedAssembly[assemblies.Count]; Stopwatch total = Stopwatch.StartNew(); Parallel.For( 0, assemblies.Count, delegate(int i) { var loader = new CecilLoader(); var path = assemblies[i].Location; loader.DocumentationProvider = GetXmlDocumentation(assemblies[i].Location); unresolvedAssemblies[i] = loader.LoadAssemblyFile(assemblies[i].Location); }); Debug.WriteLine("Init project content, loading base assemblies: " + total.Elapsed); projectContent = projectContent.AddAssemblyReferences((IEnumerable<IUnresolvedAssembly>)unresolvedAssemblies); }
public void FixtureSetUp() { // use "IncludeInternalMembers" so that Cecil results match C# parser results CecilLoader loader = new CecilLoader() { IncludeInternalMembers = true }; IUnresolvedAssembly asm = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location); compilation = new SimpleCompilation(asm, CecilLoaderTests.Mscorlib); }
public static void AddAssembly(string file) { if (String.IsNullOrEmpty(file)) return; var loader = new CecilLoader(); var unresolvedAssembly = loader.LoadAssemblyFile(file); projectContent = projectContent.AddAssemblyReferences(unresolvedAssembly); }
public CSharpAmbienceTests() { ambience = new CSharpAmbience(); mscorlib = CecilLoaderTests.Mscorlib; var loader = new CecilLoader(); loader.IncludeInternalMembers = true; myLib = loader.LoadAssemblyFile(typeof(CSharpAmbienceTests).Assembly.Location); compilation = new SimpleCompilation(myLib, mscorlib); }
public void AddAssembly(string file) { if (String.IsNullOrEmpty(file)) return; var loader = new CecilLoader(); loader.DocumentationProvider = GetXmlDocumentation(file); var unresolvedAssembly = loader.LoadAssemblyFile(file); ProjectContent = ProjectContent.AddAssemblyReferences(unresolvedAssembly); }
public void FixtureSetUp() { CecilLoader loader = new CecilLoader() { IncludeInternalMembers = true }; IProjectContent pc = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location); FastSerializer serializer = new FastSerializer(); using (MemoryStream ms = new MemoryStream()) { serializer.Serialize(ms, pc); ms.Position = 0; testCasePC = (IProjectContent)serializer.Deserialize(ms); } }
public void FixtureSetUp() { CecilLoader loader = new CecilLoader() { IncludeInternalMembers = true }; IUnresolvedAssembly pc = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location); FastSerializer serializer = new FastSerializer(); using (MemoryStream ms = new MemoryStream()) { serializer.Serialize(ms, pc); ms.Position = 0; var asm = (IUnresolvedAssembly)serializer.Deserialize(ms); base.compilation = new SimpleCompilation(asm, CecilLoaderTests.Mscorlib); } }
public MetricsReader(string fileName) { loader = new CecilLoader(true) { IncludeInternalMembers = true }; namespaceMappings = new Dictionary<string, NamespaceNode>(); typeMappings = new Dictionary<ITypeDefinition, TypeNode>(); methodMappings = new Dictionary<IMethod, MethodNode>(); fieldMappings = new Dictionary<IField, FieldNode>(); cecilMappings = new Dictionary<MemberReference, IEntity>(); compilation = new SimpleCompilation(loader.LoadAssemblyFile(fileName)); // TODO load referenced assemblies into compilation. Assembly = new AssemblyNode(compilation.MainAssembly.AssemblyName); assemblyDefinition = loader.GetCecilObject(compilation.MainAssembly.UnresolvedAssembly); foreach (var type in compilation.MainAssembly.GetAllTypeDefinitions()) { ReadType(type); foreach (IMethod method in type.Methods) { ReadMethod(method); } foreach (IProperty property in type.Properties) { if (property.CanGet) ReadMethod(property.Getter); if (property.CanSet) ReadMethod(property.Setter); } foreach (IField field in type.Fields) { ReadField(field); } } foreach (var method in methodMappings.Values) { ReadInstructions(method, method.Method, loader.GetCecilObject((IUnresolvedMethod)method.Method.UnresolvedMember)); } Assembly.namespaces = namespaceMappings.Values; }
public Minifier(MinifierOptions options = null, string[] ignoredIdentifiers = null, string[] ignoredComments = null) { Options = options ?? new MinifierOptions(); _projectContent = new CSharpProjectContent(); var assemblies = new List<Assembly> { typeof(object).Assembly, // mscorlib typeof(Uri).Assembly, // System.dll typeof(Enumerable).Assembly, // System.Core.dll }; var unresolvedAssemblies = new IUnresolvedAssembly[assemblies.Count]; Parallel.For( 0, assemblies.Count, delegate (int i) { var loader = new CecilLoader(); var path = assemblies[i].Location; unresolvedAssemblies[i] = loader.LoadAssemblyFile(assemblies[i].Location); }); _projectContent = _projectContent.AddAssemblyReferences((IEnumerable<IUnresolvedAssembly>)unresolvedAssemblies); IgnoredIdentifiers = ignoredIdentifiers == null ? new List<string>() : ignoredIdentifiers.ToList(); IgnoredComments = new List<string>(); if (ignoredComments != null) foreach (var comment in ignoredComments) { var str = comment; if (str.StartsWith("//")) str = str.Substring("//".Length); else if (str.StartsWith("/*") && str.EndsWith("*/")) str = str.Substring("/*".Length, str.Length - "/*".Length - "*/".Length); if (!IgnoredComments.Contains(str)) IgnoredComments.Add(str); } }
private static IUnresolvedAssembly GetUnresolvedAssembly(string reference) { var fullPath = reference; //look in the bin folder if (!File.Exists(fullPath)) fullPath = Path.Combine(Environment.CurrentDirectory, Constants.BinFolder, reference); if (!File.Exists(fullPath)) fullPath = Path.Combine(Environment.CurrentDirectory, Constants.BinFolder, reference+".dll"); if (!File.Exists(fullPath)) fullPath = Path.Combine(Environment.CurrentDirectory, Constants.BinFolder, reference+".exe"); //try to resolve as relaive path if (!File.Exists(fullPath)) fullPath = PathHelper.ToAbsolutePath(Environment.CurrentDirectory, reference); //try to find in GAC if (!File.Exists(fullPath)) { try { var assemblyName = new AssemblyName(reference); fullPath = GlobalAssemblyCache.FindAssemblyInNetGac(assemblyName); } catch { } } if (!File.Exists(fullPath)) { var assemblyName = GlobalAssemblyCache.FindBestMatchingAssemblyName(reference); if (assemblyName != null) fullPath = GlobalAssemblyCache.FindAssemblyInNetGac(assemblyName); } if (File.Exists(fullPath)) { var loader = new CecilLoader(); loader.DocumentationProvider = GetXmlDocumentation(fullPath); var unresolvedAssembly = loader.LoadAssemblyFile(fullPath); return unresolvedAssembly; } throw new FileNotFoundException("Reference could not be found: "+reference); }
private void UpdateScriptCode() { string scriptStart, scriptEnd; string[] loadedReferences = interactiveExecution.GetScriptHelperCode(out scriptStart, out scriptEnd).ToArray(); if (loadedReferences.Length != loadedAssemblies.Count) { var newAssemblies = new List<IUnresolvedAssembly>(); foreach (var assemblyPath in loadedReferences) if (!loadedAssemblies.ContainsKey(assemblyPath)) { try { var loader = new CecilLoader(); loader.DocumentationProvider = GetXmlDocumentation(assemblyPath); newAssemblies.Add(loader.LoadAssemblyFile(assemblyPath)); } catch (Exception) { } } if (newAssemblies.Count > 0) { projectContent = projectContent.AddAssemblyReferences(newAssemblies); } } Regex lineRegex = new Regex("#line[^\n]*", RegexOptions.Compiled); ScriptStart = lineRegex.Replace(scriptStart, ""); ScriptEnd = lineRegex.Replace(scriptEnd, ""); }
public void FixtureSetUp() { // use "IncludeInternalMembers" so that Cecil results match C# parser results CecilLoader loader = new CecilLoader() { IncludeInternalMembers = true }; testCasePC = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location); }
public void FixtureSetUp() { CecilLoader loader = new CecilLoader() { IncludeInternalMembers = true, LazyLoad = true }; IUnresolvedAssembly pc = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location); base.compilation = new SimpleCompilation(pc, CecilLoaderTests.Mscorlib); }
private static IEnumerable<IUnresolvedAssembly> GetProjectReferences(List<string> explicitReferences) { var loader = new CecilLoader(); yield return loader.LoadAssemblyFile(typeof(object).Assembly.Location); foreach (var reference in explicitReferences) yield return loader.LoadAssemblyFile(reference); }
/// <summary> /// Public translation interface. /// Translates the given method to HLSL /// </summary> /// <param name="s">Shader type definition.</param> /// <param name="m">A method representing a shader to translate.</param> /// <param name="attr">The shader type as attribute (either FragmentShaderAttribute or VertexShaderAttribute</param> /// <param name="type">The shader type as ShaderType</param> /// <returns>The translated GLSL shader source</returns> public FunctionDescription Transform(TypeDefinition s, MethodDefinition m, CustomAttribute attr, ShaderType type) { if (s == null) throw new ArgumentNullException("s"); if (m == null) throw new ArgumentNullException("m"); if (attr == null) throw new ArgumentNullException("attr"); var sbase = s.BaseType.Resolve(); while (sbase.MetadataToken.ToInt32() != typeof(Shader).MetadataToken) sbase = sbase.BaseType.Resolve(); var dctx = new DecompilerContext(s.Module) { CurrentType = s, CurrentMethod = m, CancellationToken = CancellationToken.None }; var d = AstMethodBodyBuilder.CreateMethodBody(m, dctx); //var ctx = new CecilTypeResolveContext(sbase.Module); var loader = new CecilLoader(); var mscorlib = loader.LoadAssemblyFile(typeof(object).Assembly.Location); var slsharp = loader.LoadAssembly(sbase.Module.Assembly); var project = loader.LoadAssembly(s.Module.Assembly); var ctx = new CompositeTypeResolveContext(new[] { project, slsharp, mscorlib }); var resolver = new CSharpResolver(ctx, CancellationToken.None) {UsingScope = new UsingScope(project)}; /* foreach (var v in m.Body.Variables) { resolver.AddVariable(v.VariableType, null, v.Name) }*/ //resolver.AddVariable() //resolver.LocalVariables = m.Body.Variables; // TODO: need a more sane way to get the correct class + member var ss = ctx.GetAllTypes().First(c => c.FullName == s.FullName); resolver.CurrentTypeDefinition = ss; resolver.CurrentMember = ss.Methods.First(n => SameMethod(m, n, ctx)); var rv = new ResolveVisitor(resolver, new ParsedFile("memory", resolver.UsingScope), null); var glsl = new HlslVisitor(d, attr, rv, dctx); _functions.UnionWith(glsl.Functions); var entry = (bool)attr.ConstructorArguments.FirstOrDefault().Value; var sig = HlslVisitor.GetSignature(m); var code = glsl.Result; var desc = new FunctionDescription(Shader.GetMethodName(m), sig + code, entry, type); _dependencies.UnionWith(glsl.Dependencies); return desc; }
private IUnresolvedAssembly Load(Assembly assembly) { var loader = new CecilLoader { DocumentationProvider = GetXmlDocumentation(assembly.Location) }; return loader.LoadAssemblyFile(assembly.Location); }