internal void resolveReferences(MetaDataLoader loader,
MetaDataTypeDefinition[] fieldOwners,
MetaDataTypeDefinition[] methodOwners)
{
this.extends = loader.getTypeDefOrRef(this.extendsIndex);
// fieldOwners[fieldOwners.Length-1] == null, so this is safe
int fieldEndIndex = this.fieldIndex;
while (fieldOwners[fieldEndIndex] == this)
{
loader.getField(fieldEndIndex).resolveReferences(this);
fieldEndIndex++;
}
int fieldCount = fieldEndIndex - this.fieldIndex;
this.fieldArray = loader.getFields(this.fieldIndex, fieldCount);
// methodOwners[methodOwners.Length-1] == null, so this is safe
int methodEndIndex = this.methodIndex;
while (methodOwners[methodEndIndex] == this)
{
loader.getMethod(methodEndIndex).setParent(this);
methodEndIndex++;
}
int methodCount = methodEndIndex - this.methodIndex;
this.methodArray = loader.getMethods(this.methodIndex, methodCount);
}
internal void resolveReferences(MetaDataLoader loader,
MetaDataMethod[] paramOwners)
{
this.signature = signature.resolve(loader);
// paramOwners[paramOwners.Length-1] == null, so this is safe
int paramEndIndex = this.paramIndex;
while (paramOwners[paramEndIndex] == this)
{
paramEndIndex++;
}
int paramCount = paramEndIndex - this.paramIndex;
this.paramArray = loader.getParams(this.paramIndex, paramCount);
int limit = this.paramArray.Length;
if (paramCount != limit)
{
MetaDataParam resultParam = loader.getParam(this.paramIndex);
resultParam.resolveReferences(this);
}
for (int i = 0; i < limit; i++)
{
this.paramArray[i].resolveReferences(this);
}
}
public static MetaData loadMetaData(String name,
PELoader peLoader,
bool fLoadCode,
bool fLoadDebugInfo)
{
return(MetaDataLoader.getMetaData(name, peLoader, fLoadCode, fLoadDebugInfo));
}
internal void loadInstructions(MetaDataLoader mdLoader,
PELoader peLoader,
Stream fileStream,
int[] lines,
int[] columns,
int[] offsets,
String srcFileName,
int count)
{
if (this.rva != 0)
{
if ((this.flags & (short)MethodAttributes.PinvokeImpl) == 0 ||
(this.flags & (short)MethodAttributes.UnmanagedExport) != 0)
{
int codeOffset = peLoader.VaToOffset(rva);
this.instructions =
Instruction.getInstructions(mdLoader, fileStream,
codeOffset, lines, columns,
offsets, srcFileName, count,
out this.ehTable,
out this.bbTable,
out this.maxStack,
out this.locals,
out this.initLocals);
}
else
{
Console.WriteLine("Not loading embedded native code for " +
this);
}
}
}
// This is technically not a constructor method, but it is meant to
// be used to set up the object
internal void resolveReferences(MetaDataLoader loader)
{
// Do not resolve the typeDef, as it may live in another file!
// this.typeDef = loader.getTypeDef(this.typeDefId);
this.implementation =
loader.getImplementation(this.implementationIndex);
}
public static List <Packet> LoadPackets()
{
List <Packet> list = new List <Packet>();
MetaData metaData = MetaDataLoader.Load();
Grouper.GroupingSuperKeyword(metaData);
foreach (SuperKeyword sk in metaData.superKeywords)
{
Packet packet = new Packet();
if (sk.simple)
{
packet.title = sk.keyword;
}
else if (sk.keyword == "*")
{
packet.title = string.Format("【{0}】的作品集", sk.authors[0]);
}
else if (sk.authors[0] == "*")
{
packet.title = string.Format("专题：【{0}】", sk.keyword);
}
else
{
packet.title = string.Format("【{0}】系列", sk.keyword);
}
packet.author = sk.authors[0];
packet.simple = sk.simple;
packet.chapters = new List <Chapter>();
foreach (Group g in sk.groupedTids)
{
BBSThread example = metaData.threads[g.exampleId];
string filename = example.siteId + "/" + example.threadId;
Chapter ch = new Chapter();
ch.id = filename;
ch.title = example.title;
ch.author = example.author;
ch.source = Constants.SITE_DEF[example.siteId].siteName;
ch.savePath = filename;
ch.timestamp = Utils.GetTimestamp(example.postTime);
packet.chapters.Add(ch);
}
packet.chapters.Sort((x1, x2) => x2.timestamp.CompareTo(x1.timestamp));
packet.timestamp = packet.chapters[0].timestamp;
packet.key = Utils.CalcKey(packet.title, packet.author, sk.simple);
packet.summary = Utils.CalcSumary(packet.title, packet.author, sk.simple, packet.chapters, null);
packet.source = "Forum";
list.Add(packet);
}
list.Sort((x1, x2) => x2.timestamp.CompareTo(x1.timestamp));
string packetFolder = Constants.LOCAL_PATH + "packets";
foreach (string f in Directory.EnumerateFiles(packetFolder))
{
Packet packet = LoadPacketFromZip(f);
list.Add(packet);
}
return(list);
}
internal override Signature resolveTypeSpec(MetaDataLoader mdLoader)
{
Type type = this.parseSignatureType(mdLoader);
if (this.offset != this.buffer.Length)
{
throw new MetaDataLoader.IllegalMetaDataFormatException("Only read " + this.offset + " bytes of " + this);
}
return(new SignatureTypeSpec(type));
}
public CldrLoader(string rootPath, CldrLoadOptions loadOptions = CldrLoadOptions.Normal)
{
if (File.Exists(rootPath))
{
_zip = ZipFile.OpenRead(rootPath);
}
else
{
DirectoryInfo info = new DirectoryInfo(rootPath);
if (!info.Exists)
{
throw new DirectoryNotFoundException(info.FullName);
}
rootPath = info.FullName;
if (!Directory.Exists(Path.Combine(rootPath, "main")))
{
rootPath = Path.Combine(rootPath, "common");
if (!Directory.Exists(Path.Combine(rootPath, "main")))
{
throw new FileLoadException("Not a valid CLDR folder");
}
}
Root = rootPath;
}
_scripts = XUtil.GetScriptMap();
MetaDataLoader loader = new MetaDataLoader(this);
using (XmlReader reader = OpenXmlFile("supplemental", "supplementalMetadata")) {
loader.LoadMetaData(reader);
}
if ((loadOptions & CldrLoadOptions.Subdivision) != 0)
{
using (XmlReader reader = TryOpenXmlFile("supplemental", "subdivisions")) {
if (reader != null)
{
loader.LoadSubdivisions(reader);
}
else
{
loadOptions &= ~CldrLoadOptions.Subdivision;
}
}
}
LoadOptions = loadOptions;
using (XmlReader reader = OpenXmlFile("supplemental", "supplementalData")) {
loader.Load(reader);
}
foreach (string name in GetAllLocaleNames())
{
GetLocaleInfo(name).HasFile = true;
}
}
// This is technically not a constructor method, but it is meant to
// be used to set up the object
internal void resolveReferences(MetaDataLoader loader,
ArrayList[] interfaceListArray)
{
this.classObject = loader.getTypeDef(this.classIndex);
this.interfaceObject = loader.getTypeDefOrRef(this.interfaceIndex);
if (interfaceListArray[this.classIndex] == null)
{
interfaceListArray[this.classIndex] = new ArrayList();
}
interfaceListArray[this.classIndex].Add(this.interfaceObject);
}
private Type parseSignatureLocal(MetaDataLoader mdLoader)
{
ElementTypes first = (ElementTypes)this.buffer[this.offset];
if (first == ElementTypes.PINNED)
{
this.offset++;
Type type = this.parseSignatureType(mdLoader);
return(new Type(first, type, (Modifier)null));
}
else
{
return(this.parseSignatureType(mdLoader));
}
}
private MetaDataObject uncompressToken(MetaDataLoader mdLoader)
{
uint codedToken = uncompressInt(this.buffer, ref this.offset);
MetaDataLoader.TokenType tokenType =
((((codedToken & 0x2) == 0) ?
(((codedToken & 0x1) == 0) ?
MetaDataLoader.TokenType.TypeDef :
MetaDataLoader.TokenType.TypeRef) :
(((codedToken & 0x1) == 0) ?
MetaDataLoader.TokenType.TypeSpec :
MetaDataLoader.TokenType.BaseType)));
int token = (int)(codedToken >> 2) | (int)tokenType;
return(mdLoader.getObjectFromToken(token));
}
internal void resolveReferences(MetaDataLoader loader,
PELoader peLoader,
Stream fileStream)
{
this.field.resolveReferences(this);
int dataOffset = peLoader.VaToOffsetSafe(this.rva);
if (dataOffset != -1)
{
fileStream.Seek(dataOffset, SeekOrigin.Begin);
BinaryReader reader = new BinaryReader(fileStream);
SignatureField fieldSignature = (SignatureField)
this.field.Signature;
Signature.Type fieldType = fieldSignature.FieldType;
int dataSize = this.getFieldSize(fieldType);
byte[] data = new byte[dataSize];
int count = reader.Read(data, 0, dataSize);
if (loader.HasVtableFixup() &&
loader.RVAHasRelocation(dataOffset) &&
dataSize == 4)
{
// if this corresponds to a vtable label, we need to fix it
int location = data[0] | (data[1] << 8) |
(data[2] << 16) | (data[3] << 24);
int imageBase = peLoader.getImageBase();
location -= imageBase; // use RVA
fileStream.Seek(location, SeekOrigin.Begin);
BinaryReader binaryReader = new BinaryReader(fileStream);
short prefix = binaryReader.ReadInt16();
if (prefix == 0x25FF) // this starts a vtable lable
{
count = binaryReader.Read(data, 0, 4);
}
}
this.dataBytes = data;
if (count != dataSize)
{
throw new MetaDataLoader.IllegalMetaDataFormatException("Only got " + count + " out of " + dataSize + " data bytes for FieldRVA " + this.rva);
}
}
else
{
Console.WriteLine("Found no data for " + this.field);
}
}
// This is technically not a constructor method, but it is meant to
// be used to set up the object
internal void resolveReferences(MetaDataLoader loader)
{
this.owner = loader.getTypeOrMethodDef(this.ownerIndex);
if (this.owner is MetaDataTypeDefinition)
{
((MetaDataTypeDefinition)this.owner).AddGenericParam(this);
}
else if (this.owner is MetaDataMethod)
{
((MetaDataMethod)this.owner).AddGenericParam(this);
}
else
{
throw new MetaDataLoader.IllegalMetaDataFormatException
("Unknown owner of GenericParam");
}
}
private Param parseSignatureParam(MetaDataLoader mdLoader)
{
Modifier modifierList = this.parseSignatureModifiers(mdLoader);
byte first = this.buffer[this.offset];
if (first == (byte)ElementTypes.BYREF)
{
this.offset++;
Type type = this.parseSignatureType(mdLoader);
return(new Param(modifierList, (ElementTypes)first, type));
}
else if (first == (byte)ElementTypes.TYPEDBYREF)
{
this.offset++;
return(new Param(modifierList, (ElementTypes)first, null));
}
else
{
Type type = this.parseSignatureType(mdLoader);
return(new Param(modifierList, ElementTypes.END, type));
}
}
private Modifier parseSignatureModifiers(MetaDataLoader mdLoader)
{
Modifier result = null;
ElementTypes mod = (ElementTypes)this.buffer[this.offset];
while (mod == ElementTypes.CMOD_REQD ||
mod == ElementTypes.CMOD_OPT)
{
this.offset++;
uint typeEncoded = uncompressInt(this.buffer, ref this.offset);
// BUGBUG: type conversion on int.
MetaDataObject type = mdLoader.getTypeDefOrRef((int)typeEncoded);
result = new Modifier(mod, type, result);
if (this.offset < this.buffer.Length)
{
mod = (ElementTypes)this.buffer[this.offset];
}
else
{
mod = ElementTypes.VOID;
}
}
return(result);
}
internal void resolveReferences(MetaDataLoader loader)
{
this.signature = this.signature.resolve(loader);
}
// This is technically not a constructor method, but it is meant to
// be used to set up the object
internal void resolveReferences(MetaDataLoader loader)
{
this.eventType = loader.getTypeDefOrRef(this.eventTypeIndex);
}
// This is technically not a constructor method, but it is meant to
// be used to set up the object
internal void resolveReferences(MetaDataLoader loader)
{
this.eventObject = loader.getEvent(this.eventIndex);
}
// Constructor Methods
public static MetaData loadMetaData(String name,
PELoader peLoader)
{
return(MetaDataLoader.getMetaData(name, peLoader, false, false));
}
// This is technically not a constructor method, but it is meant to
// be used to set up the object
internal void resolveReferences(MetaDataLoader loader)
{
this.parent = loader.getTypeDef(this.parentIndex);
this.parent.resolveReferences(this);
}
// This is technically not a constructor method, but it is meant to
// be used to set up the object
internal void resolveReferences(MetaDataLoader loader)
{
this.classObject = loader.getTypeDef(this.classIndex);
this.body = loader.getMethodDefOrRef(this.bodyIndex);
this.declaration = loader.getMethodDefOrRef(this.declarationIndex);
}
// This is technically not a constructor method, but it is meant to
// be used to set up the object
internal void resolveReferences(MetaDataLoader loader)
{
this.memberForwarded =
loader.getMemberForwarded(this.memberForwardedIndex);
this.importScope = loader.getModuleRef(this.importScopeIndex);
}
internal void resolveReferences(MetaDataLoader loader)
{
this.type = this.type.resolve(loader);
}
// This is technically not a constructor method, but it is meant to
// be used to set up the object
internal void resolveReferences(MetaDataLoader loader)
{
this.implementation =
loader.getImplementation(this.implementationIndex);
}
// This is technically not a constructor method, but it is meant to
// be used to set up the object
internal void resolveReferences(MetaDataLoader loader)
{
this.parent = loader.getHasCustomAttribute(this.parentIndex);
this.parent.AddCustomAttribute(this);
}
internal void resolveReferences(MetaDataLoader loader)
{
this.parent = loader.getHasFieldMarshal(this.parentIndex);
}
// This is technically not a constructor method, but it is meant to
// be used to set up the object
internal void resolveReferences(MetaDataLoader loader)
{
this.method = loader.getMethodDefOrRef(this.methodIndex);
}
// This is technically not a constructor method, but it is meant to
// be used to set up the object
internal void resolveReferences(MetaDataLoader loader)
{
this.parent = loader.getHasDeclSecurity(this.parentIndex);
}
// This is technically not a constructor method, but it is meant to
// be used to set up the object
internal void resolveReferences(MetaDataLoader loader)
{
this.classObject = loader.getMemberRefParent(this.classIndex);
this.signature = signature.resolve(loader);
}
// This is technically not a constructor method, but it is meant
// to be used to set up the object
internal void resolveReferences(MetaDataLoader loader)
{
this.resolutionScope =
loader.getResolutionScope(this.resolutionScopeIndex);
}
