public override bool View(DecompilerTextView textView)
{
AvalonEditTextOutput output = new AvalonEditTextOutput();
IHighlightingDefinition highlighting = null;
var lang = MainWindow.Instance.CurrentLanguage;
textView.RunWithCancellation(
token => Task.Factory.StartNew(
() => {
try {
bamlData.Position = 0;
var document = BamlReader.ReadDocument(bamlData, token);
if (BamlSettings.Instance.DisassembleBaml)
{
Disassemble(module, document, lang, output, out highlighting, token);
}
else
{
Decompile(module, document, lang, output, out highlighting, token);
}
}
catch (Exception ex) {
output.Write(ex.ToString(), TextTokenType.Text);
}
return(output);
}, token)
).Then(t => textView.ShowNode(t, this, highlighting)).HandleExceptions();
return(true);
}
private void ParseResource(EmbeddedResource resource)
{
ResourceReader reader;
try
{
reader = new ResourceReader(resource.CreateReader().AsStream());
}
catch (ArgumentException)
{
Console.WriteLine("This resource can not be parsed.");
//throw;
return;
}
var e = reader.GetEnumerator();
while (e.MoveNext())
{
if (e.Key.ToString().ToLower().EndsWith(".baml"))
{
reader.GetResourceData(e.Key.ToString(), out _, out var contents);
//MARK:AF 3E 00 00
contents = contents.Skip(4).ToArray(); //MARK:the first 4 bytes = length
using (var ms = new MemoryStream(contents))
{
BamlDocument b = BamlReader.ReadDocument(ms);
BamlFiles.TryAdd(e.Key.ToString(), b);
}
}
}
}
public ResourcePart(DictionaryEntry entry)
{
name = (string)entry.Key;
stream = (Stream)entry.Value;
if (Path.GetExtension(name) != ".baml")
{
return;
}
baml = BamlReader.ReadDocument(stream);
stream.Position = 0;
foreach (BamlRecord record in baml)
{
if (record.Type == BamlRecordType.TypeInfo)
{
TypeInfoRecord typeInfo = (TypeInfoRecord)record;
typeName = typeInfo.TypeFullName;
break;
}
if (record.Type == BamlRecordType.ElementStart)
{
break;
}
}
}
public static BamlDocument FromResourceBytes(byte[] rawResourceData)
{
byte[] streamBytes = rawResourceData.Skip(4).ToArray();
using (var bamlStream = new MemoryStream(streamBytes))
{
return(BamlReader.ReadDocument(bamlStream));
}
}
private static BamlDocument GetResourceBamlDocument(string filename)
{
Application.ResourceAssembly = Assembly.GetExecutingAssembly();
var streamInfo = Application.GetResourceStream(new Uri("/Resources/BamlGeneration/GenericXaml/" + filename, UriKind.Relative));
var expectedBamlDocument = BamlReader.ReadDocument(streamInfo.Stream);
return(expectedBamlDocument);
}
internal static XDocument LoadIntoDocument(PEFile module, IAssemblyResolver assemblyResolver,
Stream stream, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var document = BamlReader.ReadDocument(stream, cancellationToken);
var xaml = new XamlDecompiler().Decompile(new BamlDecompilerTypeSystem(module, assemblyResolver), document, cancellationToken, new BamlDecompilerOptions(), null);
return(xaml);
}
public IList <string> Decompile(ModuleDef module, byte[] data, CancellationToken token, BamlDecompilerOptions bamlDecompilerOptions, Stream output, XamlOutputOptions outputOptions)
{
var doc = BamlReader.ReadDocument(new MemoryStream(data), token);
var asmRefs = new List <string>();
var xaml = new XamlDecompiler().Decompile(module, doc, token, bamlDecompilerOptions, asmRefs);
var resData = Encoding.UTF8.GetBytes(new XamlOutputCreator(outputOptions).CreateText(xaml));
output.Write(resData, 0, resData.Length);
return(asmRefs);
}
public static ResourceDictionary ReadCommonThemes()
{
var sri = Application.GetResourceStream(
new Uri("/Iris.Desktop.UI;component/CommonThemes.xaml", UriKind.Relative));
if (sri != null)
{
return((ResourceDictionary)BamlReader.Load(sri.Stream));
}
return(new ResourceDictionary());
}
public string Decompile(IDecompilerOutput output, CancellationToken token)
{
var lang = Context.Decompiler;
var document = BamlReader.ReadDocument(new MemoryStream(bamlData), token);
if (bamlSettings.DisassembleBaml)
{
Disassemble(module, document, output, token);
return(ContentTypes.BamlDnSpy);
}
else
{
Decompile(module, document, lang, output, token);
return(ContentTypes.Xaml);
}
}
public DocumentTreeNodeData Create(ModuleDef module, ResourceElement resourceElement, ITreeNodeGroup treeNodeGroup)
{
if (resourceElement.ResourceData.Code != ResourceTypeCode.ByteArray && resourceElement.ResourceData.Code != ResourceTypeCode.Stream)
{
return(null);
}
var data = (byte[])((BuiltInResourceData)resourceElement.ResourceData).Data;
if (!BamlReader.IsBamlHeader(new MemoryStream(data)))
{
return(null);
}
return(new BamlResourceElementNode(module, resourceElement, data, treeNodeGroup, bamlSettings, xamlOutputOptionsProvider, documentWriterService));
}
public IResourceElementNode Create(ModuleDef module, ResourceElement resourceElement, ITreeNodeGroup treeNodeGroup)
{
if (resourceElement.ResourceData.Code != ResourceTypeCode.ByteArray && resourceElement.ResourceData.Code != ResourceTypeCode.Stream)
{
return(null);
}
var data = (byte[])((BuiltInResourceData)resourceElement.ResourceData).Data;
if (!BamlReader.IsBamlHeader(new MemoryStream(data)))
{
return(null);
}
return(new BamlResourceElementNode(module, resourceElement, data, treeNodeGroup, bamlSettings));
}
public string Decompile(ITextOutput output, CancellationToken token)
{
string ext = null;
var lang = Context.Language;
var document = BamlReader.ReadDocument(new MemoryStream(bamlData), token);
if (bamlSettings.DisassembleBaml)
{
Disassemble(module, document, lang, output, out ext, token);
}
else
{
Decompile(module, document, lang, output, out ext, token);
}
return(ext);
}
private List <BamlDocument> ReadDocuments()
{
var documents = new List <BamlDocument>();
foreach (var resource in Module.Resources.OfType <EmbeddedResource>())
{
var match = ResourceNamePattern.Match(resource.Name);
if (!match.Success)
{
continue;
}
using (var resourceStream = resource.CreateReader().AsStream()) {
using (var resourceReader = new ResourceReader(resourceStream)) {
var enumerator = resourceReader.GetEnumerator();
while (enumerator.MoveNext())
{
var name = (string)enumerator.Key;
if (!name.EndsWith(".baml"))
{
continue;
}
resourceReader.GetResourceData(name, out var typeName, out var data);
using (var bamlStream = new MemoryStream(data, 4, data.Length - 4)) {
var document = BamlReader.ReadDocument(bamlStream);
document.DocumentName = name;
documents.Add(document);
}
}
}
}
}
return(documents);
}
public BamlDecompilationResult Decompile(Stream stream)
{
var ct = CancellationToken;
var document = BamlReader.ReadDocument(stream, ct);
var ctx = XamlContext.Construct(typeSystem, document, ct, settings);
var handler = HandlerMap.LookupHandler(ctx.RootNode.Type);
var elem = handler.Translate(ctx, ctx.RootNode, null);
var xaml = new XDocument();
xaml.Add(elem.Xaml.Element);
foreach (var pass in rewritePasses)
{
ct.ThrowIfCancellationRequested();
pass.Run(ctx, xaml);
}
var assemblyReferences = ctx.Baml.AssemblyIdMap.Select(a => a.Value.AssemblyFullName);
return(new BamlDecompilationResult(xaml, assemblyReferences));
}
//-----------------------------
// private methods
//-----------------------------
/// <summary>
/// build the baml element tree as well as the localizability inheritance tree
/// </summary>
/// <param name="bamlSteam">input baml stream.</param>
/// <returns>the tree constructed.</returns>
private BamlTree LoadBamlImp(Stream bamlSteam)
{
_reader = new BamlReader(bamlSteam);
_reader.Read();
if (_reader.NodeType != BamlNodeType.StartDocument)
{
throw new XamlParseException(SR.Get(SRID.InvalidStartOfBaml));
}
// create root element.
_root = new BamlStartDocumentNode();
PushNodeToStack(_root);
// A hash table used to handle duplicate properties within an element
Hashtable propertyOccurrences = new Hashtable(8);
// create the tree by depth first traversal.
while (_bamlTreeStack.Count > 0 && _reader.Read())
{
switch (_reader.NodeType)
{
case BamlNodeType.StartElement:
{
BamlTreeNode bamlNode = new BamlStartElementNode(
_reader.AssemblyName,
_reader.Name,
_reader.IsInjected,
_reader.CreateUsingTypeConverter
);
PushNodeToStack(bamlNode);
break;
}
case BamlNodeType.EndElement:
{
BamlTreeNode bamlNode = new BamlEndElementNode();
AddChildToCurrentParent(bamlNode);
PopStack();
break;
}
case BamlNodeType.StartComplexProperty:
{
BamlStartComplexPropertyNode bamlNode = new BamlStartComplexPropertyNode(
_reader.AssemblyName,
_reader.Name.Substring(0, _reader.Name.LastIndexOf('.')),
_reader.LocalName
);
bamlNode.LocalizabilityAncestor = PeekPropertyStack(bamlNode.PropertyName);
PushPropertyToStack(bamlNode.PropertyName, (ILocalizabilityInheritable)bamlNode);
PushNodeToStack(bamlNode);
break;
}
case BamlNodeType.EndComplexProperty:
{
BamlTreeNode bamlNode = new BamlEndComplexPropertyNode();
AddChildToCurrentParent(bamlNode);
PopStack();
break;
}
case BamlNodeType.Event:
{
BamlTreeNode bamlNode = new BamlEventNode(_reader.Name, _reader.Value);
AddChildToCurrentParent(bamlNode);
break;
}
case BamlNodeType.RoutedEvent:
{
BamlTreeNode bamlNode = new BamlRoutedEventNode(
_reader.AssemblyName,
_reader.Name.Substring(0, _reader.Name.LastIndexOf('.')),
_reader.LocalName,
_reader.Value
);
AddChildToCurrentParent(bamlNode);
break;
}
case BamlNodeType.PIMapping:
{
BamlTreeNode bamlNode = new BamlPIMappingNode(
_reader.XmlNamespace,
_reader.ClrNamespace,
_reader.AssemblyName
);
AddChildToCurrentParent(bamlNode);
break;
}
case BamlNodeType.LiteralContent:
{
BamlTreeNode bamlNode = new BamlLiteralContentNode(_reader.Value);
AddChildToCurrentParent(bamlNode);
break;
}
case BamlNodeType.Text:
{
BamlTreeNode bamlNode = new BamlTextNode(
_reader.Value,
_reader.TypeConverterAssemblyName,
_reader.TypeConverterName
);
AddChildToCurrentParent(bamlNode);
break;
}
case BamlNodeType.StartConstructor:
{
BamlTreeNode bamlNode = new BamlStartConstructorNode();
AddChildToCurrentParent(bamlNode);
break;
}
case BamlNodeType.EndConstructor:
{
BamlTreeNode bamlNode = new BamlEndConstructorNode();
AddChildToCurrentParent(bamlNode);
break;
}
case BamlNodeType.EndDocument:
{
BamlTreeNode bamlNode = new BamlEndDocumentNode();
AddChildToCurrentParent(bamlNode);
PopStack();
break;
}
default:
{
throw new XamlParseException(SR.Get(SRID.UnRecognizedBamlNodeType, _reader.NodeType));
}
}
// read properties if it has any.
if (_reader.HasProperties)
{
// The Hashtable is used to auto-number repeated properties. The usage is as the following:
// When encountering the 1st occurrence of the property, it stores a reference to the property's node (BamlTreeNode).
// When encountering the property the 2nd time, we start auto-numbering the property including the 1st occurrence
// and store the index count (int) in the slot from that point onwards.
propertyOccurrences.Clear();
_reader.MoveToFirstProperty();
do
{
switch (_reader.NodeType)
{
case BamlNodeType.ConnectionId:
{
BamlTreeNode bamlNode = new BamlConnectionIdNode(_reader.ConnectionId);
AddChildToCurrentParent(bamlNode);
break;
}
case BamlNodeType.Property:
{
BamlPropertyNode bamlNode = new BamlPropertyNode(
_reader.AssemblyName,
_reader.Name.Substring(0, _reader.Name.LastIndexOf('.')),
_reader.LocalName,
_reader.Value,
_reader.AttributeUsage
);
bamlNode.LocalizabilityAncestor = PeekPropertyStack(bamlNode.PropertyName);
PushPropertyToStack(bamlNode.PropertyName, (ILocalizabilityInheritable)bamlNode);
AddChildToCurrentParent(bamlNode);
if (propertyOccurrences.Contains(_reader.Name))
{
// we autonumber properties that have occurrences larger than 1
object occurrence = propertyOccurrences[_reader.Name];
int index = 2;
if (occurrence is BamlPropertyNode)
{
// start numbering this property as the 2nd occurrence is encountered
// the value stores the 1st occurrence of the property at this point
((BamlPropertyNode)occurrence).Index = 1;
}
else
{
// For the 3rd or more occurrences, the value stores the next index
// to assign to the property
index = (int)occurrence;
}
// auto-number the current property node
((BamlPropertyNode)bamlNode).Index = index;
propertyOccurrences[_reader.Name] = ++index;
}
else
{
// store the first occurrence of the property
propertyOccurrences[_reader.Name] = bamlNode;
}
break;
}
case BamlNodeType.DefAttribute:
{
if (_reader.Name == XamlReaderHelper.DefinitionUid)
{
// set the Uid proeprty when we see it.
((BamlStartElementNode)_currentParent).Uid = _reader.Value;
}
BamlTreeNode bamlNode = new BamlDefAttributeNode(
_reader.Name,
_reader.Value
);
AddChildToCurrentParent(bamlNode);
break;
}
case BamlNodeType.XmlnsProperty:
{
BamlTreeNode bamlNode = new BamlXmlnsPropertyNode(
_reader.LocalName,
_reader.Value
);
AddChildToCurrentParent(bamlNode);
break;
}
case BamlNodeType.ContentProperty:
{
BamlTreeNode bamlNode = new BamlContentPropertyNode(
_reader.AssemblyName,
_reader.Name.Substring(0, _reader.Name.LastIndexOf('.')),
_reader.LocalName
);
AddChildToCurrentParent(bamlNode);
break;
}
case BamlNodeType.PresentationOptionsAttribute:
{
BamlTreeNode bamlNode = new BamlPresentationOptionsAttributeNode(
_reader.Name,
_reader.Value
);
AddChildToCurrentParent(bamlNode);
break;
}
default:
{
throw new XamlParseException(SR.Get(SRID.UnRecognizedBamlNodeType, _reader.NodeType));
}
}
} while (_reader.MoveToNextProperty());
}
}
// At this point, the baml tree stack should be completely unwinded and also nothing more to read.
if (_reader.Read() || _bamlTreeStack.Count > 0)
{
throw new XamlParseException(SR.Get(SRID.InvalidEndOfBaml));
}
return(new BamlTree(_root, _nodeCount));
//notice that we don't close the input stream because we don't own it.
}
private void ProcessBaml(ModuleDefinition mod, Dictionary <string, BamlDocument> bamls, ref int cc, DictionaryEntry entry, Stream stream)
{
cc++;
docName = entry.Key as string;
doc = BamlReader.ReadDocument(stream);
(mod as IAnnotationProvider).Annotations[RenMode] = NameMode.Letters;
for (int i = 0; i < doc.Count; i++)
{
if (doc[i] is LineNumberAndPositionRecord || doc[i] is LinePositionRecord)
{
doc.RemoveAt(i); i--;
}
}
int asmId = -1;
Dictionary <ushort, AssemblyDefinition> asms = new Dictionary <ushort, AssemblyDefinition>();
foreach (var rec in doc.OfType <AssemblyInfoRecord>())
{
AssemblyNameReference nameRef = AssemblyNameReference.Parse(rec.AssemblyFullName);
if (nameRef.Name == mod.Assembly.Name.Name)
{
asmId = rec.AssemblyId;
rec.AssemblyFullName = GetBamlAssemblyFullName(mod.Assembly.Name);
asms.Add(rec.AssemblyId, mod.Assembly);
PopulateMembers(mod.Assembly);
nameRef = null;
}
else
{
bool added = false;
foreach (var i in ivtMap)
{
if (i.Key.Name.Name == nameRef.Name)
{
rec.AssemblyFullName = GetBamlAssemblyFullName(i.Key.Name);
asms.Add(rec.AssemblyId, i.Key);
PopulateMembers(i.Key);
nameRef = null;
added = true;
break;
}
}
if (!added)
{
var asmRefDef = GlobalAssemblyResolver.Instance.Resolve(nameRef);
if (asmRefDef != null)
{
PopulateMembers(asmRefDef);
}
}
}
}
Dictionary <ushort, TypeDefinition> types = new Dictionary <ushort, TypeDefinition>();
foreach (var rec in doc.OfType <TypeInfoRecord>())
{
AssemblyDefinition asm;
if (asms.TryGetValue((ushort)(rec.AssemblyId & 0xfff), out asm))
{
TypeReference type = TypeParser.ParseType(asm.MainModule, rec.TypeFullName);
if (type != null)
{
types.Add(rec.TypeId, type.Resolve());
AddTypeRenRefs(type, type, rec);
rec.TypeFullName = TypeParser.ToParseable(type);
}
}
}
Dictionary <string, string> xmlns = new Dictionary <string, string>();
foreach (var rec in doc.OfType <XmlnsPropertyRecord>())
{
xmlns[rec.Prefix] = rec.XmlNamespace;
}
Dictionary <ushort, string> ps = new Dictionary <ushort, string>();
foreach (var rec in doc.OfType <AttributeInfoRecord>())
{
if (types.ContainsKey(rec.OwnerTypeId))
{
PropertyDefinition prop = types[rec.OwnerTypeId].Properties.SingleOrDefault(p => p.Name == rec.Name);
if (prop != null)
{
((prop as IAnnotationProvider).Annotations[RenRef] as List <IReference>).Add(new BamlAttributeReference(rec));
}
EventDefinition evt = types[rec.OwnerTypeId].Events.SingleOrDefault(p => p.Name == rec.Name);
if (evt != null)
{
((evt as IAnnotationProvider).Annotations[RenRef] as List <IReference>).Add(new BamlAttributeReference(rec));
}
FieldDefinition field = types[rec.OwnerTypeId].Fields.SingleOrDefault(p => p.Name == rec.Name);
if (field != null)
{
((field as IAnnotationProvider).Annotations[RenRef] as List <IReference>).Add(new BamlAttributeReference(rec));
}
//Attached property
MethodDefinition getM = types[rec.OwnerTypeId].Methods.SingleOrDefault(p => p.Name == "Get" + rec.Name);
if (getM != null)
{
(getM as IAnnotationProvider).Annotations[RenOk] = false;
}
MethodDefinition setM = types[rec.OwnerTypeId].Methods.SingleOrDefault(p => p.Name == "Set" + rec.Name);
if (setM != null)
{
(setM as IAnnotationProvider).Annotations[RenOk] = false;
}
}
ps.Add(rec.AttributeId, rec.Name);
}
foreach (var rec in doc.OfType <PropertyWithConverterRecord>())
{
if (rec.ConverterTypeId == 0xfd4c || ((short)rec.AttributeId > 0 && ps[rec.AttributeId] == "TypeName")) //TypeExtension
{
string type = rec.Value;
string xmlNamespace;
if (type.IndexOf(':') != -1)
{
xmlNamespace = xmlns[type.Substring(0, type.IndexOf(':'))];
type = type.Substring(type.IndexOf(':') + 1, type.Length - type.IndexOf(':') - 1);
}
else
{
xmlNamespace = xmlns[""];
}
TypeDefinition typeDef;
if ((typeDef = ResolveXmlns(xmlNamespace, type, mod.Assembly, asms.Values)) != null)
{
((typeDef as IAnnotationProvider).Annotations[RenRef] as List <IReference>).Add(new BamlTypeExtReference(rec, doc, typeDef.Module.Assembly.Name.Name));
}
}
if (rec.ConverterTypeId == 0xff77 || rec.ConverterTypeId == 0xfe14 || rec.ConverterTypeId == 0xfd99)
{
ProcessProperty(rec, rec.Value);
}
}
for (int i = 1; i < doc.Count; i++)
{
ElementStartRecord binding = doc[i - 1] as ElementStartRecord;
ConstructorParametersStartRecord param = doc[i] as ConstructorParametersStartRecord;
if (binding != null && param != null && binding.TypeId == 0xffec)//Binding
{
TextRecord path = doc[i + 1] as TextRecord;
ProcessProperty(path, path.Value);
}
}
var rootRec = doc.OfType <ElementStartRecord>().FirstOrDefault();
if (rootRec != null && types.ContainsKey(rootRec.TypeId))
{
TypeDefinition root = types[rootRec.TypeId];
Dictionary <string, IMemberDefinition> m = new Dictionary <string, IMemberDefinition>();
foreach (PropertyDefinition prop in root.Properties)
{
m.Add(prop.Name, prop);
}
foreach (EventDefinition evt in root.Events)
{
m.Add(evt.Name, evt);
}
//foreach (MethodDefinition mtd in root.Methods)
// mems.Add(mtd.Name, mtd);
foreach (var rec in doc.OfType <PropertyRecord>())
{
if (!(rec.Value is string))
{
continue;
}
if (m.ContainsKey((string)rec.Value))
{
((m[(string)rec.Value] as IAnnotationProvider).Annotations[RenRef] as List <IReference>).Add(new BamlPropertyReference(rec));
}
}
}
bamls.Add(entry.Key as string, doc);
}
void AnalysisResource(ModuleDefinition mod, int resId)
{
EmbeddedResource res = mod.Resources[resId] as EmbeddedResource;
ResourceReader resRdr = new ResourceReader(res.GetResourceStream());
Dictionary <string, object> ress;
Dictionary <string, BamlDocument> bamls;
(res as IAnnotationProvider).Annotations["Gresources"] = ress = new Dictionary <string, object>();
(res as IAnnotationProvider).Annotations["Gbamls"] = bamls = new Dictionary <string, BamlDocument>();
int cc = 0;
foreach (DictionaryEntry entry in resRdr)
{
Stream stream = null;
if (entry.Value is Stream)
{
byte[] buff = new byte[(entry.Value as Stream).Length];
(entry.Value as Stream).Position = 0;
(entry.Value as Stream).Read(buff, 0, buff.Length);
ress.Add(entry.Key as string, stream = new MemoryStream(buff));
}
else
{
ress.Add(entry.Key as string, entry.Value);
}
if (stream != null && (entry.Key as string).EndsWith(".baml"))
{
BamlDocument doc = BamlReader.ReadDocument(stream);
int c = 0;
int asmId = -1;
foreach (var rec in doc.OfType <AssemblyInfoRecord>())
{
if (AssemblyNameReference.Parse(rec.AssemblyFullName).Name == mod.Assembly.Name.Name)
{
asmId = rec.AssemblyId;
}
}
Dictionary <ushort, TypeDefinition> types = new Dictionary <ushort, TypeDefinition>();
foreach (var rec in doc.OfType <TypeInfoRecord>())
{
if ((rec.AssemblyId & 0xfff) == asmId)
{
TypeDefinition type = mod.GetType(rec.TypeFullName);
if (type != null)
{
types.Add(rec.TypeId, type);
((type as IAnnotationProvider).Annotations["RenRef"] as List <IReference>).Add(new BamlTypeReference(rec));
c++; cc++;
}
}
}
Dictionary <ushort, PropertyDefinition> ps = new Dictionary <ushort, PropertyDefinition>();
foreach (var rec in doc.OfType <AttributeInfoRecord>())
{
if (types.ContainsKey(rec.OwnerTypeId))
{
PropertyDefinition prop = types[rec.OwnerTypeId].Properties.FirstOrDefault(p => p.Name == rec.Name);
if (prop != null && types[rec.OwnerTypeId].Fields.FirstOrDefault(fld => fld.Name == prop.Name + "Property") == null)
{
((prop as IAnnotationProvider).Annotations["RenRef"] as List <IReference>).Add(new BamlAttributeReference(rec));
c++; cc++;
}
}
}
var rootRec = doc.OfType <ElementStartRecord>().FirstOrDefault();
if (rootRec != null && types.ContainsKey(rootRec.TypeId))
{
TypeDefinition root = types[rootRec.TypeId];
Dictionary <string, IMemberDefinition> mems = new Dictionary <string, IMemberDefinition>();
foreach (PropertyDefinition prop in root.Properties)
{
mems.Add(prop.Name, prop);
}
foreach (EventDefinition evt in root.Events)
{
mems.Add(evt.Name, evt);
}
foreach (MethodDefinition mtd in root.Methods)
{
mems.Add(mtd.Name, mtd);
}
foreach (var rec in doc.OfType <PropertyRecord>())
{
if (!(rec.Value is string))
{
continue;
}
if (mems.ContainsKey((string)rec.Value))
{
((mems[(string)rec.Value] as IAnnotationProvider).Annotations["RenRef"] as List <IReference>).Add(new BamlPropertyReference(rec));
c++; cc++;
}
}
}
if (c != 0)
{
bamls.Add(entry.Key as string, doc);
}
}
}
if (cc != 0)
{
((res as IAnnotationProvider).Annotations["RenRef"] as List <IReference>).Add(new SaveBamlsReference(mod, resId));
}
}
