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