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 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 ModuleMetadataInfo(Module module, Mono.Cecil.ModuleDefinition cecilModule)
{
this.Module = module;
this.CecilModule = cecilModule;
typeRefLoader = new CecilLoader();
typeRefLoader.SetCurrentModule(cecilModule);
}
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 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 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 CecilTypeResolveContext(ModuleDefinition module)
{
this.loader = new CecilLoader();
this.loader.IncludeInternalMembers = true;
this.module = module;
this.namespaces = module.Types.Select(t => t.Namespace).Distinct().ToArray();
List<IAttribute> assemblyAttributes = new List<IAttribute>();
foreach (var attr in module.Assembly.CustomAttributes) {
assemblyAttributes.Add(loader.ReadAttribute(attr));
}
this.AssemblyAttributes = assemblyAttributes.AsReadOnly();
}
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);
}
}
public AssemblyBrowserWidget ()
{
this.Build ();
buttonBack = new Gtk.Button (ImageService.GetImage ("md-breadcrumb-prev", Gtk.IconSize.Menu));
buttonBack.Clicked += OnNavigateBackwardActionActivated;
buttonForeward = new Gtk.Button (ImageService.GetImage ("md-breadcrumb-next", Gtk.IconSize.Menu));
buttonForeward.Clicked += OnNavigateForwardActionActivated;
comboboxVisibilty = ComboBox.NewText ();
comboboxVisibilty.InsertText (0, GettextCatalog.GetString ("Only public members"));
comboboxVisibilty.InsertText (1, GettextCatalog.GetString ("All members"));
comboboxVisibilty.Active = 0;
comboboxVisibilty.Changed += delegate {
TreeView.PublicApiOnly = comboboxVisibilty.Active == 0;
FillInspectLabel ();
};
searchentry1 = new MonoDevelop.Components.SearchEntry ();
searchentry1.Ready = true;
searchentry1.HasFrame = true;
searchentry1.WidthRequest = 200;
searchentry1.Visible = true;
searchentry1.EmptyMessage = GettextCatalog.GetString ("Search for types or members");
searchentry1.InnerEntry.Changed += SearchEntryhandleChanged;
CheckMenuItem checkMenuItem = this.searchentry1.AddFilterOption (0, GettextCatalog.GetString ("Types"));
checkMenuItem.Active = true;
checkMenuItem.Toggled += delegate {
if (checkMenuItem.Active) {
searchMode = AssemblyBrowserWidget.SearchMode.Type;
CreateColumns ();
StartSearch ();
}
};
CheckMenuItem checkMenuItem1 = this.searchentry1.AddFilterOption (1, GettextCatalog.GetString ("Members"));
checkMenuItem1.Toggled += delegate {
if (checkMenuItem1.Active) {
searchMode = AssemblyBrowserWidget.SearchMode.Member;
CreateColumns ();
StartSearch ();
}
};
languageCombobox = Gtk.ComboBox.NewText ();
//languageCombobox.AppendText (GettextCatalog.GetString ("Summary"));
languageCombobox.AppendText (GettextCatalog.GetString ("IL"));
languageCombobox.AppendText (GettextCatalog.GetString ("C#"));
languageCombobox.Active = Math.Min (1, PropertyService.Get ("AssemblyBrowser.InspectLanguage", 1));
languageCombobox.Changed += LanguageComboboxhandleChanged;
loader = new CecilLoader (true);
loader.IncludeInternalMembers = true;
TreeView = new AssemblyBrowserTreeView (new NodeBuilder[] {
new ErrorNodeBuilder (),
new ProjectNodeBuilder (this),
new AssemblyNodeBuilder (this),
new ModuleReferenceNodeBuilder (),
new AssemblyReferenceNodeBuilder (this),
//new AssemblyReferenceFolderNodeBuilder (this),
new AssemblyResourceFolderNodeBuilder (),
new ResourceNodeBuilder (),
new NamespaceBuilder (this),
new DomTypeNodeBuilder (this),
new DomMethodNodeBuilder (this),
new DomFieldNodeBuilder (this),
new DomEventNodeBuilder (this),
new DomPropertyNodeBuilder (this),
new BaseTypeFolderNodeBuilder (this),
new BaseTypeNodeBuilder (this)
}, new TreePadOption [0]);
TreeView.Tree.Selection.Mode = Gtk.SelectionMode.Single;
TreeView.Tree.CursorChanged += HandleCursorChanged;
TreeView.ShadowType = ShadowType.None;
TreeView.BorderWidth = 1;
TreeView.ShowBorderLine = false;
TreeView.Zoom = 1.0;
treeViewPlaceholder.Add (TreeView);
// this.descriptionLabel.ModifyFont (Pango.FontDescription.FromString ("Sans 9"));
// this.documentationLabel.ModifyFont (Pango.FontDescription.FromString ("Sans 12"));
// this.documentationLabel.ModifyBg (Gtk.StateType.Normal, new Gdk.Color (255, 255, 225));
// this.documentationLabel.Wrap = true;
var options = new MonoDevelop.Ide.Gui.CommonTextEditorOptions () {
ShowFoldMargin = false,
ShowIconMargin = false,
ShowLineNumberMargin = false,
HighlightCaretLine = true,
};
inspectEditor = new TextEditor (new TextDocument (), options);
inspectEditor.ButtonPressEvent += HandleInspectEditorButtonPressEvent;
this.inspectEditor.Document.ReadOnly = true;
// this.inspectEditor.Document.SyntaxMode = new Mono.TextEditor.Highlighting.MarkupSyntaxMode ();
this.inspectEditor.TextViewMargin.GetLink = delegate(Mono.TextEditor.MarginMouseEventArgs arg) {
var loc = inspectEditor.PointToLocation (arg.X, arg.Y);
int offset = inspectEditor.LocationToOffset (loc);
var referencedSegment = ReferencedSegments != null ? ReferencedSegments.FirstOrDefault (seg => seg.Segment.Contains (offset)) : null;
if (referencedSegment == null)
return null;
if (referencedSegment.Reference is TypeDefinition)
return new XmlDocIdGenerator ().GetXmlDocPath ((TypeDefinition)referencedSegment.Reference);
if (referencedSegment.Reference is MethodDefinition)
return new XmlDocIdGenerator ().GetXmlDocPath ((MethodDefinition)referencedSegment.Reference);
if (referencedSegment.Reference is PropertyDefinition)
return new XmlDocIdGenerator ().GetXmlDocPath ((PropertyDefinition)referencedSegment.Reference);
if (referencedSegment.Reference is FieldDefinition)
return new XmlDocIdGenerator ().GetXmlDocPath ((FieldDefinition)referencedSegment.Reference);
if (referencedSegment.Reference is EventDefinition)
return new XmlDocIdGenerator ().GetXmlDocPath ((EventDefinition)referencedSegment.Reference);
if (referencedSegment.Reference is FieldDefinition)
return new XmlDocIdGenerator ().GetXmlDocPath ((FieldDefinition)referencedSegment.Reference);
if (referencedSegment.Reference is TypeReference) {
return new XmlDocIdGenerator ().GetXmlDocPath ((TypeReference)referencedSegment.Reference);
}
return referencedSegment.Reference.ToString ();
};
this.inspectEditor.LinkRequest += InspectEditorhandleLinkRequest;
documentationScrolledWindow.Add (inspectEditor);
this.hpaned1.ExposeEvent += HPaneExpose;
hpaned1 = hpaned1.ReplaceWithWidget (new HPanedThin (), true);
hpaned1.Position = 271;
this.notebook1.SetTabLabel (this.documentationScrolledWindow, new Label (GettextCatalog.GetString ("Documentation")));
this.notebook1.SetTabLabel (this.searchWidget, new Label (GettextCatalog.GetString ("Search")));
notebook1.Page = 0;
//this.searchWidget.Visible = false;
typeListStore = new Gtk.ListStore (typeof(Xwt.Drawing.Image), // type image
typeof(string), // name
typeof(string), // namespace
typeof(string), // assembly
typeof(IMember)
);
memberListStore = new Gtk.ListStore (typeof(Xwt.Drawing.Image), // member image
typeof(string), // name
typeof(string), // Declaring type full name
typeof(string), // assembly
typeof(IMember)
);
CreateColumns ();
// this.searchEntry.Changed += SearchEntryhandleChanged;
this.searchTreeview.RowActivated += SearchTreeviewhandleRowActivated;
this.notebook1.ShowTabs = false;
this.ShowAll ();
}
private static IEnumerable<IAssemblyReference> LoadReferences(IEnumerable<string> references, IErrorReporter er)
{
var loader = new CecilLoader { IncludeInternalMembers = true };
var assemblies = references.Select(r => AssemblyDefinition.ReadAssembly(r)).ToList(); // Shouldn't result in errors because mcs would have caught it.
var indirectReferences = ( from a in assemblies
from m in a.Modules
from r in m.AssemblyReferences
select r.Name)
.Distinct();
var directReferences = from a in assemblies select a.Name.Name;
var missingReferences = indirectReferences.Except(directReferences).ToList();
if (missingReferences.Count > 0) {
er.Region = DomRegion.Empty;
foreach (var r in missingReferences)
er.Message(7996, r);
return null;
}
return assemblies.Select(a => loader.LoadAssembly(a)).ToList();
}
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, "");
}
LoadedAssembly LoadAssembly(FileName fileName, CancellationToken cancellationToken, bool includeInternalMembers)
{
DateTime lastWriteTime = File.GetLastWriteTimeUtc(fileName);
string cacheFileName = GetCacheFileName(fileName);
LoadedAssembly pc = TryReadFromCache(cacheFileName, lastWriteTime);
if (pc != null) {
if (!includeInternalMembers || includeInternalMembers == pc.HasInternalMembers)
return pc;
}
//LoggingService.Debug("Loading " + fileName);
cancellationToken.ThrowIfCancellationRequested();
var param = new ReaderParameters();
param.AssemblyResolver = new DummyAssemblyResolver();
ModuleDefinition module = ModuleDefinition.ReadModule(fileName, param);
CecilLoader l = new CecilLoader();
l.IncludeInternalMembers = includeInternalMembers;
string xmlDocFile = FindXmlDocumentation(fileName, module.Runtime);
if (xmlDocFile != null) {
try {
l.DocumentationProvider = new XmlDocumentationProvider(xmlDocFile);
} catch (XmlException ex) {
LoggingService.Warn("Ignoring error while reading xml doc from " + xmlDocFile, ex);
} catch (IOException ex) {
LoggingService.Warn("Ignoring error while reading xml doc from " + xmlDocFile, ex);
} catch (UnauthorizedAccessException ex) {
LoggingService.Warn("Ignoring error while reading xml doc from " + xmlDocFile, ex);
}
}
l.CancellationToken = cancellationToken;
var references = module.AssemblyReferences
.Select(anr => new DomAssemblyName(anr.FullName));
pc = new LoadedAssembly(l.LoadModule(module), lastWriteTime, includeInternalMembers, references);
SaveToCacheAsync(cacheFileName, lastWriteTime, pc).FireAndForget();
//SaveToCache(cacheFileName, lastWriteTime, pc);
return pc;
}
void InitMembers(CecilLoader loader)
{
this.AddDefaultConstructorIfRequired = (this.ClassType == ClassType.Struct || this.ClassType == ClassType.Enum);
if (typeDefinition.HasMethods) {
foreach (MethodDefinition method in typeDefinition.Methods) {
if (loader.IsVisible(method.Attributes)) {
EntityType type = EntityType.Method;
if (method.IsSpecialName) {
if (method.IsConstructor)
type = EntityType.Constructor;
else if (method.Name.StartsWith("op_", StringComparison.Ordinal))
type = EntityType.Operator;
else
continue;
}
this.Methods.Add(loader.ReadMethod(method, this, type));
}
}
}
if (typeDefinition.HasFields) {
foreach (FieldDefinition field in typeDefinition.Fields) {
if (loader.IsVisible(field.Attributes) && !field.IsSpecialName) {
this.Fields.Add(loader.ReadField(field, this));
}
}
}
if (typeDefinition.HasProperties) {
string defaultMemberName = null;
var defaultMemberAttribute = typeDefinition.CustomAttributes.FirstOrDefault(
a => a.AttributeType.FullName == typeof(System.Reflection.DefaultMemberAttribute).FullName);
if (defaultMemberAttribute != null && defaultMemberAttribute.ConstructorArguments.Count == 1) {
defaultMemberName = defaultMemberAttribute.ConstructorArguments[0].Value as string;
}
foreach (PropertyDefinition property in typeDefinition.Properties) {
bool getterVisible = property.GetMethod != null && loader.IsVisible(property.GetMethod.Attributes);
bool setterVisible = property.SetMethod != null && loader.IsVisible(property.SetMethod.Attributes);
if (getterVisible || setterVisible) {
EntityType type = property.Name == defaultMemberName ? EntityType.Indexer : EntityType.Property;
this.Properties.Add(loader.ReadProperty(property, this, type));
}
}
}
if (typeDefinition.HasEvents) {
foreach (EventDefinition ev in typeDefinition.Events) {
if (ev.AddMethod != null && loader.IsVisible(ev.AddMethod.Attributes)) {
this.Events.Add(loader.ReadEvent(ev, this));
}
}
}
}
/// <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);
}
void InitNestedTypes(CecilLoader loader)
{
if (!typeDefinition.HasNestedTypes)
return;
foreach (TypeDefinition nestedType in typeDefinition.NestedTypes) {
TypeAttributes visibility = nestedType.Attributes & TypeAttributes.VisibilityMask;
if (loader.IncludeInternalMembers
|| visibility == TypeAttributes.NestedPublic
|| visibility == TypeAttributes.NestedFamily
|| visibility == TypeAttributes.NestedFamORAssem)
{
string name = nestedType.Name;
int pos = name.LastIndexOf('/');
if (pos > 0)
name = name.Substring(pos + 1);
if (name.Length == 0 || name[0] == '<')
continue;
name = ReflectionHelper.SplitTypeParameterCountFromReflectionName(name);
InnerClasses.Add(new CecilTypeDefinition(this, name, nestedType));
}
}
foreach (CecilTypeDefinition innerClass in this.InnerClasses) {
innerClass.Init(loader);
}
}
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);
}
internal static List<IAssemblyReference> ToAssemblyReferences(IEnumerable<AssemblyDefinition> references)
{
var list = new List<IAssemblyReference>();
if (references == null)
{
return list;
}
foreach (var reference in references)
{
var loader = new CecilLoader();
loader.IncludeInternalMembers = true;
list.Add(loader.LoadAssembly(reference));
}
return list;
}
public IEnumerable<ILLocalVariable> GetLocalVariables(IMethod method)
{
string id = IdStringProvider.GetIdString(method.MemberDefinition);
var file = GetSymbols(method);
if (file == null || !file.DebugSymbols.ContainsKey(id))
return null;
var symbols = file.DebugSymbols[id];
var context = new SimpleTypeResolveContext(method);
var loader = new CecilLoader();
return symbols.LocalVariables.Where(v => v.OriginalVariable != null).Select(
v => new Debugger.ILLocalVariable() {
Index = v.OriginalVariable.Index,
Type = loader.ReadTypeReference(v.Type).Resolve(context),
Name = v.Name,
IsCompilerGenerated = false,
ILRanges = new [] { new ILRange(0, int.MaxValue) }
});
}
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);
}
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);
}
static IUnresolvedAssembly LoadModule(Module module, string fileName)
{
var param = new Mono.Cecil.ReaderParameters { AssemblyResolver = new DummyAssemblyResolver() };
var cecilModule = Mono.Cecil.ModuleDefinition.ReadModule(fileName, param);
var moduleMetadataInfo = new ModuleMetadataInfo(module, cecilModule);
var loader = new CecilLoader();
loader.IncludeInternalMembers = true;
loader.LazyLoad = true;
loader.OnEntityLoaded = moduleMetadataInfo.AddMember;
var asm = loader.LoadModule(cecilModule);
weakTable.Add(asm, moduleMetadataInfo);
return asm;
}
public AssemblyBrowserWidget ()
{
this.Build ();
loader = new CecilLoader (true);
loader.IncludeInternalMembers = true;
TreeView = new AssemblyBrowserTreeView (new NodeBuilder[] {
new ErrorNodeBuilder (),
new ProjectNodeBuilder (this),
new AssemblyNodeBuilder (this),
new ModuleReferenceNodeBuilder (),
new AssemblyReferenceNodeBuilder (this),
new AssemblyReferenceFolderNodeBuilder (this),
new AssemblyResourceFolderNodeBuilder (),
new ResourceNodeBuilder (),
new NamespaceBuilder (this),
new DomTypeNodeBuilder (this),
new DomMethodNodeBuilder (this),
new DomFieldNodeBuilder (this),
new DomEventNodeBuilder (this),
new DomPropertyNodeBuilder (this),
new BaseTypeFolderNodeBuilder (this),
new BaseTypeNodeBuilder (this)
}, new TreePadOption [] {
new TreePadOption ("PublicApiOnly", GettextCatalog.GetString ("Show public members only"), true)
});
TreeView.Tree.Selection.Mode = Gtk.SelectionMode.Single;
TreeView.Tree.CursorChanged += HandleCursorChanged;
TreeView.ShadowType = ShadowType.In;
treeViewPlaceholder.Add (TreeView);
treeViewPlaceholder.ShowAll ();
// this.descriptionLabel.ModifyFont (Pango.FontDescription.FromString ("Sans 9"));
this.documentationLabel.ModifyFont (Pango.FontDescription.FromString ("Sans 12"));
this.documentationLabel.ModifyBg (Gtk.StateType.Normal, new Gdk.Color (255, 255, 225));
this.documentationLabel.Wrap = true;
var options = new MonoDevelop.Ide.Gui.CommonTextEditorOptions () {
ShowFoldMargin = false,
ShowIconMargin = false,
ShowInvalidLines = false,
ShowLineNumberMargin = false,
ShowSpaces = false,
ShowTabs = false,
HighlightCaretLine = true,
};
inspectEditor = new TextEditor (new TextDocument (), options);
inspectEditor.ButtonPressEvent += HandleInspectEditorButtonPressEvent;
this.inspectEditor.Document.ReadOnly = true;
// this.inspectEditor.Document.SyntaxMode = new Mono.TextEditor.Highlighting.MarkupSyntaxMode ();
this.inspectEditor.TextViewMargin.GetLink = delegate(Mono.TextEditor.MarginMouseEventArgs arg) {
var loc = inspectEditor.PointToLocation (arg.X, arg.Y);
int offset = inspectEditor.LocationToOffset (loc);
var referencedSegment = ReferencedSegments != null ? ReferencedSegments.FirstOrDefault (seg => seg.Segment.Contains (offset)) : null;
if (referencedSegment == null)
return null;
if (referencedSegment.Reference is TypeDefinition)
return new XmlDocIdGenerator ().GetXmlDocPath ((TypeDefinition)referencedSegment.Reference);
if (referencedSegment.Reference is MethodDefinition)
return new XmlDocIdGenerator ().GetXmlDocPath ((MethodDefinition)referencedSegment.Reference);
if (referencedSegment.Reference is PropertyDefinition)
return new XmlDocIdGenerator ().GetXmlDocPath ((PropertyDefinition)referencedSegment.Reference);
if (referencedSegment.Reference is FieldDefinition)
return new XmlDocIdGenerator ().GetXmlDocPath ((FieldDefinition)referencedSegment.Reference);
if (referencedSegment.Reference is EventDefinition)
return new XmlDocIdGenerator ().GetXmlDocPath ((EventDefinition)referencedSegment.Reference);
if (referencedSegment.Reference is FieldDefinition)
return new XmlDocIdGenerator ().GetXmlDocPath ((FieldDefinition)referencedSegment.Reference);
if (referencedSegment.Reference is TypeReference) {
return new XmlDocIdGenerator ().GetXmlDocPath ((TypeReference)referencedSegment.Reference);
}
return referencedSegment.Reference.ToString ();
};
this.inspectEditor.LinkRequest += InspectEditorhandleLinkRequest;
var scrolledWindow = new SmartScrolledWindow ();
scrolledWindow.Show ();
textEditorContainer = new TextEditorContainer (inspectEditor);
scrolledWindow.Child = textEditorContainer;
notebookInspection.Add (scrolledWindow);
var notebookChild = ((Notebook.NotebookChild)(notebookInspection [scrolledWindow]));
notebookChild.Position = 1;
// this.inspectLabel.ModifyBg (Gtk.StateType.Normal, new Gdk.Color (255, 255, 250));
// this.vpaned1.ExposeEvent += VPaneExpose;
this.hpaned1.ExposeEvent += HPaneExpose;
/* this.notebook1.SwitchPage += delegate {
// Hack for the switch page select all bug.
// this.inspectLabel.Selectable = false;
};*/
languageCombobox.AppendText (GettextCatalog.GetString ("Summary"));
languageCombobox.AppendText (GettextCatalog.GetString ("IL"));
languageCombobox.AppendText (GettextCatalog.GetString ("C#"));
languageCombobox.Active = PropertyService.Get ("AssemblyBrowser.InspectLanguage", 2);
languageCombobox.Changed += LanguageComboboxhandleChanged;
searchentry1.Ready = true;
searchentry1.WidthRequest = 200;
searchentry1.Visible = true;
searchentry1.EmptyMessage = GettextCatalog.GetString ("Search for types or members");
searchentry1.InnerEntry.Changed += SearchEntryhandleChanged;
CheckMenuItem checkMenuItem = this.searchentry1.AddFilterOption (0, GettextCatalog.GetString ("Types"));
checkMenuItem.Active = true;
checkMenuItem.Toggled += delegate {
if (checkMenuItem.Active) {
searchMode = AssemblyBrowserWidget.SearchMode.Type;
CreateColumns ();
StartSearch ();
}
};
CheckMenuItem checkMenuItem1 = this.searchentry1.AddFilterOption (1, GettextCatalog.GetString ("Members"));
checkMenuItem1.Toggled += delegate {
if (checkMenuItem1.Active) {
searchMode = AssemblyBrowserWidget.SearchMode.Member;
CreateColumns ();
StartSearch ();
}
};
comboboxVisibilty.InsertText (0, GettextCatalog.GetString ("Only public members"));
comboboxVisibilty.InsertText (1, GettextCatalog.GetString ("All members"));
comboboxVisibilty.Active = 0;
comboboxVisibilty.Changed += delegate {
TreeView.PublicApiOnly = comboboxVisibilty.Active == 0;
FillInspectLabel ();
};
/*
this.searchInCombobox.Active = 0;
this.searchInCombobox.Changed += SearchInComboboxhandleChanged;
*/
this.notebook1.SetTabLabel (this.documentationScrolledWindow, new Label (GettextCatalog.GetString ("Documentation")));
this.notebook1.SetTabLabel (this.notebookInspection, new Label (GettextCatalog.GetString ("Inspect")));
this.notebook1.SetTabLabel (this.searchWidget, new Label (GettextCatalog.GetString ("Search")));
//this.searchWidget.Visible = false;
typeListStore = new Gtk.ListStore (typeof(Gdk.Pixbuf), // type image
typeof(string), // name
typeof(string), // namespace
typeof(string), // assembly
typeof(IMember)
);
memberListStore = new Gtk.ListStore (typeof(Gdk.Pixbuf), // member image
typeof(string), // name
typeof(string), // Declaring type full name
typeof(string), // assembly
typeof(IMember)
);
CreateColumns ();
SetInspectWidget ();
// this.searchEntry.Changed += SearchEntryhandleChanged;
this.searchTreeview.RowActivated += SearchTreeviewhandleRowActivated;
this.searchentry1.ShowAll ();
this.buttonBack.Clicked += this.OnNavigateBackwardActionActivated;
this.buttonForeward.Clicked += this.OnNavigateForwardActionActivated;
this.notebook1.ShowTabs = false;
this.notebookInspection.ShowTabs = false;
this.ShowAll ();
}
IList<IUnresolvedAssembly> LoadAssemblies()
{
var resolver = new AssemblyResolver();
foreach (var path in fileNames.Select(f => Path.GetDirectoryName(f)).Distinct(StringComparer.OrdinalIgnoreCase))
resolver.AddSearchDirectory(path);
List<AssemblyDefinition> assemblies = new List<AssemblyDefinition>();
foreach (var file in fileNames.Distinct(StringComparer.OrdinalIgnoreCase))
assemblies.Add(resolver.LoadAssemblyFile(file));
foreach (var asm in assemblies.ToArray())
assemblies.AddRange(asm.Modules.SelectMany(m => m.AssemblyReferences).Select(r => resolver.TryResolve(r)).Where(r => r != null));
CecilLoader loader = new CecilLoader { IncludeInternalMembers = true };
// Emulate the old CecilLoader.GetCecilObject() API:
loader.OnEntityLoaded = delegate(IUnresolvedEntity entity, MemberReference cecilObj) {
unresolvedTypeSystemToCecilDict[entity] = cecilObj;
};
var loadedAssemblies = new List<IUnresolvedAssembly>();
foreach (var asm in assemblies.Distinct()) {
var loadedAssembly = loader.LoadAssembly(asm);
loadedAssemblies.Add(loadedAssembly);
unresolvedTypeSystemToCecilDict[loadedAssembly] = asm;
}
return loadedAssemblies;
}
public void Init(CecilLoader loader)
{
InitModifiers();
if (typeDefinition.HasGenericParameters) {
for (int i = 0; i < typeDefinition.GenericParameters.Count; i++) {
loader.AddConstraints(this, (DefaultTypeParameter)this.TypeParameters[i], typeDefinition.GenericParameters[i]);
}
}
InitNestedTypes(loader); // nested types can be initialized only after generic parameters were created
loader.AddAttributes(typeDefinition, this);
this.HasExtensionMethods = HasExtensionAttribute(typeDefinition);
// set base classes
if (typeDefinition.IsEnum) {
foreach (FieldDefinition enumField in typeDefinition.Fields) {
if (!enumField.IsStatic) {
BaseTypes.Add(loader.ReadTypeReference(enumField.FieldType, entity: this));
break;
}
}
} else {
if (typeDefinition.BaseType != null) {
BaseTypes.Add(loader.ReadTypeReference(typeDefinition.BaseType, entity: this));
}
if (typeDefinition.HasInterfaces) {
foreach (TypeReference iface in typeDefinition.Interfaces) {
BaseTypes.Add(loader.ReadTypeReference(iface, entity: this));
}
}
}
InitMembers(loader);
this.typeDefinition = null;
Freeze(); // freeze after initialization
ApplyInterningProvider(loader.InterningProvider);
}
