private void AddStruct(ITypeDefinition strct, StringBuilder key)
{
if (strct.Namespace == "")
{
lock (Structs)
{
foreach (var typeArg in strct.TypeParameters)
{
foreach (var constraint in typeArg.DirectBaseTypes)
{
key.Append(constraint.Name);
}
}
if (Structs.ContainsKey(key.ToString()))
{
return;
}
Structs.Add(key.ToString(), new StructProperties(strct));
}
}
else
{
AddNamespace(key, strct);
}
}
public bool DefineStruct(StructElement data)
{
Structs.Add(data);
return(true);
}
public void AddStruct(Lexeme nameToken, StructDecl node, ErrorHandler errorHandler)
{
if (FindStructName(nameToken) != null)
{
errorHandler.AddMessage(Severity.Error, $"Duplicate declaration of struct '{nameToken.Value}'", nameToken);
return;
}
Structs.Add(nameToken.Value, node);
}
public void AddStruct(TSLStruct struct_)
{
Structs.Add(struct_);
if (struct_.Depth < StructSettings.MaxDepth)
{
StructsBeforeMaxDepth.Add(struct_);
if (!struct_.DynamicLengthed)
{
FixedLengthStructsBeforeMaxDepth.Add(struct_);
}
}
}
public StructDef LookupOrCreateStruct(string name)
{
var def = Structs.Lookup(name);
if (def == null)
{
def = new StructDef {
Name = name,
Predecl = true,
TypeBuilder = this,
};
Structs.Add(name, def);
}
return(def);
}
public void SetStruct(Class c)
{
if (c.IsClass)
{
return;
}
foreach (var @struct in Structs)
{
if (@struct == c)
{
return;
}
}
Structs.Add(c);
}
//Добавляет структуры всех таблиц базы фомата Tbl_*_sub*
public void AddDbStructs(DaoDb db) //База данных
{
db.ConnectDao();
foreach (TableDef t in db.Database.TableDefs)
{
if (t.Name.StartsWith("Tbl_") && t.Name.Substring(t.Name.Length - 5, 4) == "_Sub")
{
int level = t.Name.Substring(t.Name.Length - 1).ToInt();
string code = t.Name.Substring(4, t.Name.Length - 9);
if (!Structs.ContainsKey(code))
{
Structs.Add(code, new TablGroup(db.File, code));
}
Structs[code].AddTabl(db, t.Name, level);
}
}
}
private void AddStruct(IType strct, StringBuilder key)
{
lock (Structs)
{
foreach (var typeArg in strct.TypeParameters)
{
foreach (var constraint in typeArg.Constraints)
{
key.Append(constraint.Name);
}
}
if (Structs.ContainsKey(key.ToString()))
{
return;
}
Structs.Add(key.ToString(), new StructProperties(strct));
}
}
void ProcessTagStructs(BlamLib.CheApe.ProjectState state, IO.XmlStream s)
{
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "Struct")
{
continue;
}
s.SaveCursor(n);
var block = new TagStruct(state, s);
s.RestoreCursor();
string name_str = block.ToString();
try { Structs.Add(name_str, block); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag struct definition", name_str); }
}
}
private void ConstuctInputDependencies()
{
var dependenciesRedi = new InputDependencies();
var dependencies = BackingData.AsKeyValueCollection().GetArray("m_InputDependencies");
foreach (var dependency in dependencies)
{
var dependencyRedi = new InputDependencies.InputDependency
{
ContentRelativeFilename = dependency.GetProperty <string>("m_RelativeFilename"),
ContentSearchPath = dependency.GetProperty <string>("m_SearchPath"),
FileCRC = (uint)dependency.GetUnsignedIntegerProperty("m_nFileCRC"),
};
dependenciesRedi.List.Add(dependencyRedi);
}
Structs.Add(REDIStruct.InputDependencies, dependenciesRedi);
}
private void ConstructSpecialDependencies()
{
var specialDependenciesRedi = new SpecialDependencies();
var specialDependencies = BackingData.AsKeyValueCollection().GetArray("m_SpecialDependencies");
foreach (var specialDependency in specialDependencies)
{
var specialDependencyRedi = new SpecialDependencies.SpecialDependency
{
String = specialDependency.GetProperty <string>("m_String"),
CompilerIdentifier = specialDependency.GetProperty <string>("m_CompilerIdentifier"),
Fingerprint = specialDependency.GetIntegerProperty("m_nFingerprint"),
UserData = specialDependency.GetIntegerProperty("m_nUserData"),
};
specialDependenciesRedi.List.Add(specialDependencyRedi);
}
Structs.Add(REDIStruct.SpecialDependencies, specialDependenciesRedi);
}
public override void SetupParser()
{
Parser = (t) =>
{
switch (t.Class)
{
case TokenClass.Define:
switch (t.Token)
{
case Token.Module:
Console.WriteLine("Parsing Define.");
Console.WriteLine("Module:" + PeekNext().Text);
var mod = new VSModule(TokStream);
Structs.Add(mod);
// Console.WriteLine("Parsed module name:" + mod.ModuleName);
break;
}
break;
}
};
}
public override void SetupParser()
{
PreParser = (t) =>
{
ModuleName = t.Text;
};
Parser = (t) =>
{
switch (t.Class)
{
case TokenClass.Type:
Console.WriteLine("Parsing Variable definitions.");
BackOne();
var vdef = new VSDefineVars(TokStream);
Structs.Add(vdef);
break;
}
};
}
//Добавляет структуру одной группы таблиц
public TablGroup AddStruct(DaoDb db, //База данных
string table0, string table1 = null, string table2 = null, string table3 = null) //Имена таблиц разной вложенности
{
db.ConnectDao();
var s = new TablGroup(db.File, table0);
Structs.Add(table0, s);
s.AddTabl(db, table0, 0);
if (!table1.IsEmpty())
{
s.AddTabl(db, table1, 1);
}
if (!table2.IsEmpty())
{
s.AddTabl(db, table2, 2);
}
if (!table3.IsEmpty())
{
s.AddTabl(db, table3, 3);
}
return(s);
}
// Makes two shallow passes over the declarations inside a class to obtain
// the names and types of all consts, methods and structs declared at the
// top level; without this info, typechecking cannot begin.
private void prePass(AST node)
{
addPredeclared();
AST_kary decls = node as AST_kary;
if (decls == null || decls.Tag != NodeType.DeclList)
{
throw new Exception("Bad argument passed to prePass");
}
// make one pass over the declarations just to enter the names of structs into
// the Structs table
int arity = decls.NumChildren;
for (int i = 0; i < arity; i++)
{
AST ch = decls[i];
if (ch.Tag != NodeType.Struct)
{
continue; // it was not a struct declaration
}
string name = ((AST_leaf)(ch[0])).Sval;
if (Structs.ContainsKey(name))
{
ReportError(ch[0].LineNumber, "Duplicate declaration of struct {0}", name);
}
else
{
Structs.Add(name, new CbStruct(name));
}
}
// now make a second pass over the declarations to
// 1. add const declarations to the Consts table
// 2. add method declarations to the Methods table
// 3. fill in the field details for each struct in the Structs table
for (int i = 0; i < arity; i++)
{
AST ch = decls[i];
string name;
CbType typ;
int argsize;
switch (ch.Tag)
{
case NodeType.Struct:
CbStruct str;
name = ((AST_leaf)(ch[0])).Sval;
// find existing struct
Structs.TryGetValue(name, out str); // do error checking
AST fldlst = ch[1];
AST fld;
AST idlst;
argsize = fldlst.NumChildren;
int idsize;
// iterate through the field list
for (int j = 0; j < argsize; j++)
{
// get field declaration
fld = fldlst[j];
// find declaration type
typ = lookUpType(fld[0]);
// get list of variables declared
idlst = fld[1];
idsize = idlst.NumChildren;
// add all declared variables to the struct
for (int k = 0; k < idsize; k++)
{
str.AddField(((AST_leaf)(idlst[k])).Sval, typ);
}
}
break;
case NodeType.Const:
// Add the name and type of this constant to the Consts table
name = ((AST_leaf)(ch[1])).Sval;
typ = lookUpType(ch[0]);
if (Consts.ContainsKey(name))
{
ReportError(ch[0].LineNumber, "Duplicate declaration of const {0}", name);
}
else
{
Consts.Add(name, typ);
}
break;
case NodeType.Method:
name = ((AST_leaf)(ch[1])).Sval;
ch[2].Accept(this);
// check for duplicate method
CbMethod existing = getMethod(name, ch[2], false);
if (existing != null)
{
ReportError(ch[0].LineNumber, "Duplicate declaration of method {0}", name);
break;
}
CbType typm = CbType.Void;
// create new CbMethod
if (ch[0] != null)
{
typm = lookUpType(ch[0]);
}
CbMethod method = new CbMethod(name, typm);
// add argument list (full signature) to CbMethod
AST args = ch[2];
for (int j = 0; j < args.NumChildren; j++)
{
method.ArgType.Add(lookUpType(args[j][0]));
}
// get list of overloaded methods sharing same name
List <CbMethod> methods;
if (!Methods.TryGetValue(name, out methods)) // if none exist create new list
{
methods = new List <CbMethod>();
}
// add method to list
methods.Add(method);
// replace old list of methods with this name with new list
Methods[name] = methods;
break;
default:
throw new Exception("Unexpected node type " + ch.Tag);
}
}
}
public void ApplyFoo(XElement childElement, bool isValue)
{
var addressElements = childElement.Elements("address").ToList();
if (addressElements.Count == 0)
{
var child = CreateChild(childElement, isValue);
child.StartAddress = StartAddress + ChildOffset;
child.FileAddress = FileAddress + FileOffset;
child.Parse();
ChildOffset += child.Size;
if (!IsExcludedFromFileOffset(child.ValuePath))
{
FileOffset += child.FileSize;
}
if (isValue)
{
Values.Add((RolandValue)child);
}
else
{
Structs.Add((RolandStruct)child);
}
}
else
{
var arrayIndex = 0;
bool useArrayIndex = addressElements.Count > 1;
foreach (var addressElement in addressElements)
{
var childOffset = ParseAddress(addressElement.Value, 0);
var fileOffset = isValue ? ParseAddress(addressElement.Value, 0) : FileOffset;
var typeElement = childElement.Element("type");
var childName = "";
if (typeElement != null)
{
childName = childElement.Element("type").Value;
}
else
{
childName = "notset";
}
if (!isValue)
{
Debug.WriteLine(
$"ParseAddress for {childName} {addressElement.Value} with file offset {FileOffset:X} results in filestart {FileAddress:X} wih offset {fileOffset:X}. ChildOffset is {childOffset:X}");
}
var child = CreateChild(childElement, isValue);
child.StartAddress = StartAddress + childOffset;
child.FileAddress = FileAddress + fileOffset;
child.UseArrayIndex = useArrayIndex;
child.ArrayIndex = arrayIndex;
child.Parse();
arrayIndex++;
if (childOffset + child.Size > ChildOffset)
{
ChildOffset = childOffset + child.Size;
}
if (!IsExcludedFromFileOffset(child.ValuePath))
{
if (IsAbsoluteAddress(addressElement.Value))
{
if (fileOffset + child.FileSize > FileOffset)
{
FileOffset = fileOffset + child.FileSize;
}
}
else
{
if (fileOffset + child.Size > FileOffset)
{
FileOffset = fileOffset + child.Size;
}
}
}
if (isValue)
{
Values.Add((RolandValue)child);
}
else
{
Structs.Add((RolandStruct)child);
}
}
}
}
/* static readonly List<uint> _fieldids = new List<uint>();
* /// <summary>
* ///
* /// </summary>
* internal static List<uint> FieldIds
* { get { return _fieldids; } } */
#endregion Properties (static)
#region Methods (static)
/// <summary>
/// Reads a GFF-file and parses out its data to a GFFData object.
/// @note Sections will be extracted in a non-arbitrary sequence because
/// the data in a specific section could rely on the data in a different
/// section. The order I have chosen is:
/// 1. Header data (ofc)
/// 2. FieldIndices
/// 3. Structs - relies on FieldIndices
/// 4. Labels
/// 5. Fields - relies on Structs and Labels and extracts FieldData and ListIndices
/// </summary>
/// <param name="pfe">path-file-extension - ensure file exists before call</param>
internal static GffData ReadGFFfile(string pfe)
{
Structs.Clear(); // Structs and Fields will be cleared after load completes
Fields.Clear(); // but do it here (before load starts) also - jic.
byte[] bytes = FileService.ReadFile(pfe);
if (bytes != null)
{
if (bytes.Length != 0)
{
uint pos = 0;
uint b;
var buffer = new byte[8];
for (b = 0; b != 8; ++b)
{
buffer[b] = bytes[pos++];
}
string ver = Encoding.ASCII.GetString(buffer, 0, buffer.Length);
if (ver.Substring(3) != Globals.SupportedVersion)
{
FileService.error("That is not a version 3.2 GFF file.");
return(null);
}
bool le = BitConverter.IsLittleEndian; // hardware architecture
var data = new GffData(pfe);
data.TypeVer = ver;
data.Type = GffData.GetGffType(ver.Substring(0, 3));
data.Latest = File.GetLastWriteTime(pfe);
FileWatchDialog.Bypass = false;
// HEADER METADATA ->
pos = head_StructOffset;
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
uint StructOffset = BitConverter.ToUInt32(buffer, 0);
//logfile.Log("StructOffset= " + StructOffset);
// The Struct-section will always start at 56-bytes (0x38)
if (StructOffset != Globals.Length_HEADER)
{
FileService.error("That does not appear to be a GFF file.");
return(null);
}
pos = head_StructCount;
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
uint StructCount = BitConverter.ToUInt32(buffer, 0); // count of elements
//logfile.Log("StructCount= " + StructCount);
pos = head_FieldOffset;
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
uint FieldOffset = BitConverter.ToUInt32(buffer, 0);
//logfile.Log("FieldOffset= " + FieldOffset);
pos = head_FieldCount;
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
uint FieldCount = BitConverter.ToUInt32(buffer, 0); // count of elements
//logfile.Log("FieldCount= " + FieldCount);
pos = head_LabelOffset;
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
uint LabelOffset = BitConverter.ToUInt32(buffer, 0);
//logfile.Log("LabelOffset= " + LabelOffset);
pos = head_LabelCount;
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
uint LabelCount = BitConverter.ToUInt32(buffer, 0); // count of elements
//logfile.Log("LabelCount= " + LabelCount);
pos = head_FieldDataOffset;
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
uint FieldDataOffset = BitConverter.ToUInt32(buffer, 0);
//logfile.Log("FieldDataOffset= " + FieldDataOffset);
pos = head_FieldDataLength;
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
uint FieldDataCount = BitConverter.ToUInt32(buffer, 0); // count of bytes (not used.)
//logfile.Log("FieldDataCount= " + FieldDataCount);
pos = head_FieldIndicesOffset;
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
uint FieldIndicesOffset = BitConverter.ToUInt32(buffer, 0);
//logfile.Log("FieldIndicesOffset= " + FieldIndicesOffset);
pos = head_FieldIndicesLength;
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
uint FieldIndicesCount = BitConverter.ToUInt32(buffer, 0); // count of bytes
//logfile.Log("FieldIndicesCount= " + FieldIndicesCount);
pos = head_ListIndicesOffset;
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
uint ListIndicesOffset = BitConverter.ToUInt32(buffer, 0);
//logfile.Log("ListIndicesOffset= " + ListIndicesOffset);
pos = head_ListIndicesLength;
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
uint ListIndicesCount = BitConverter.ToUInt32(buffer, 0); // count of bytes (not used.)
//logfile.Log("ListIndicesCount= " + ListIndicesCount);
//logfile.Log("");
// FIELDID DATA -> contains the FieldIds of Structs that contain > 1 field (is req'd for parsing Structs)
// - a list of DWORD ids into the Fields section
//logfile.Log("FIELDIDS");
//int fid = 0; // log
var fieldids = new List <uint>();
pos = FieldIndicesOffset;
while (pos != FieldIndicesOffset + FieldIndicesCount)
{
//logfile.Log(". start= " + FieldIndicesOffset + " stop= " + (FieldIndicesOffset + FieldIndicesCount));
//logfile.Log(". fid #" + fid++);
buffer = new byte[4]; // 4-byte DWORD - field id
for (b = 0; b != 4; ++b)
{
//logfile.Log(". . pos= " + pos);
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
fieldids.Add(BitConverter.ToUInt32(buffer, 0)); // WARNING: There is no safety on the count below.
}
// STRUCT DATA ->
// - DWORD type-id
// - DWORD dataordataoffset
// - DWORD fieldcount
uint fields, idoroffset, i, j;
pos = StructOffset;
for (i = 0; i != StructCount; ++i)
{
//logfile.Log("Struct #" + i);
var st = new Struct();
buffer = new byte[4]; // type-id ->
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
st.typeid = BitConverter.ToUInt32(buffer, 0);
//logfile.Log(". typid= " + st.typeid);
buffer = new byte[4]; // dataordataoffset ->
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
idoroffset = BitConverter.ToUInt32(buffer, 0); // if fields=1 -> id into the FieldArray
// if fields>1 -> offset into FieldIndices -> list of ids into the FieldArray
buffer = new byte[4]; // fieldcount ->
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
fields = BitConverter.ToUInt32(buffer, 0);
//logfile.Log(". fields= " + fields);
st.fieldids = new List <uint>();
if (fields == 1) // get the FieldId directly w/ the Struct's 'idoroffset' id ->
{
//logfile.Log(". . idoroffset/id= " + idoroffset);
//logfile.Log(". . data._fields.Count= " + data._fields.Count);
st.fieldids.Add(idoroffset);
}
else if (fields > 1) // get the FieldIds out of the FieldIndices w/ the 'idoroffset' offset ->
{
uint fieldid;
for (j = 0; j != fields; ++j)
{
//logfile.Log(". . [" + j + "] idoroffset/offset= " + idoroffset + " -> fieldids id= " + (idoroffset / 4 + j));
//logfile.Log(". . data._fieldids Length= " + (data._fieldids.Count * 4));
//logfile.Log(". . data._fields.Count= " + data._fields.Count);
fieldid = fieldids[(int)(idoroffset / Globals.Length_DWORD + j)]; // 4 bytes in each DWORD (ie. convert offset to id id)
//logfile.Log(". . fieldid= " + fieldid);
st.fieldids.Add(fieldid); // isn't the GFF format wonderful ... at least it works
} // the Bioware documentation could be better.
} // Ps. it contains inaccurate and unspecific info
Structs.Add(st);
}
// LABEL DATA -> contains Labels for the Fields (is req'd for parsing Fields)
// - each label shall be unique across the entire GFF data
// - 16-CHAR
var labels = new List <string>();
string label;
pos = LabelOffset;
for (i = 0; i != LabelCount; ++i)
{
buffer = new byte[Globals.Length_LABEL]; // 16-byte CHAR(s) - label length
for (b = 0; b != Globals.Length_LABEL; ++b)
{
buffer[b] = bytes[pos++];
}
label = Encoding.ASCII.GetString(buffer, 0, buffer.Length).TrimEnd('\0');
labels.Add(label);
}
// FIELD DATA ->
// - the doc contradicts itself by saying that the TopLevelStruct is the 1st
// entry in the Fields section but that the Fields section does not contain
// the TopLevelStruct ... the latter appears to be correct: the first Field in
// a toolset-written FieldsArray is "Description" eg.
// - DWORD datatype
// - DWORD label-id
// - DWORD dataordataoffset
// - if BYTE,CHAR,WORD,SHORT,DWORD,INT,FLOAT -> dataordataoffset is a value.
// - if DWORD64,INT64,DOUBLE,CExoString,CResRef,CExoLocString -> dataordataoffset
// is an offset from the start of the FieldDataBlock section to complex data:
// - DWORD64 8-bytes
// - INT64 8-bytes
// - DOUBLE 8-bytes
// - CExoString DWORD (length) + chars
// - CExoLocString DWORD (total length) + DWORD (strref) + DWORD (stringcount) + [INT (id) + INT (length) + chars]
// - CResRef 1-byte (length) + chars (lowercase)
// - VOID arbitrary
// - if Struct -> dataordataoffset is an id into the Struct section.
// - if List -> dataordataoffset is an offset from the start of the ListIndices
// section to an array of DWORDs, the first of which is the count of DWORDS
// that follow, which are ids into the Struct section.
uint offset, length, count;
pos = FieldOffset;
for (i = 0; i != FieldCount; ++i)
{
var field = new GffData.Field();
buffer = new byte[4]; // 4-byte DWORD - field type
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
field.type = (FieldTypes)BitConverter.ToUInt32(buffer, 0);
buffer = new byte[4]; // 4-byte DWORD - field label id
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[pos++];
}
if (!le)
{
Array.Reverse(buffer);
}
field.label = labels[(int)BitConverter.ToUInt32(buffer, 0)];
//logfile.Log("label= " + field.label);
buffer = new byte[4]; // 4-byte DWORD - field data (val, is not a DWORD per se) or data
for (b = 0; b != 4; ++b) // offset into (a) DataBlock or (b) ListIds or id into (c) Structs
{
buffer[b] = bytes[pos++];
}
switch (field.type)
{
// WARNING: non-Complex types whose size is less than or
// equal to 4-bytes are (according to the doc) contained
// in the first byte(s) of the dataordataoffset 'DWORD'.
case FieldTypes.BYTE:
field.BYTE = buffer[0];
break;
case FieldTypes.CHAR:
{
var a = (sbyte[])(object)new[] { buffer[0] };
field.CHAR = a[0];
break;
}
case FieldTypes.WORD:
{
var a = new byte[2];
if (le)
{
a[0] = buffer[0];
a[1] = buffer[1];
}
else
{
a[0] = buffer[1];
a[1] = buffer[0];
}
field.WORD = BitConverter.ToUInt16(a, 0);
break;
}
case FieldTypes.SHORT:
{
var a = new byte[2];
if (le)
{
a[0] = buffer[0];
a[1] = buffer[1];
}
else
{
a[0] = buffer[1];
a[1] = buffer[0];
}
field.SHORT = BitConverter.ToInt16(a, 0);
break;
}
case FieldTypes.DWORD:
if (!le)
{
Array.Reverse(buffer);
}
field.DWORD = BitConverter.ToUInt32(buffer, 0);
break;
case FieldTypes.INT:
if (!le)
{
Array.Reverse(buffer);
}
field.INT = BitConverter.ToInt32(buffer, 0);
break;
case FieldTypes.DWORD64:
if (!le)
{
Array.Reverse(buffer);
}
offset = FieldDataOffset + BitConverter.ToUInt32(buffer, 0);
buffer = new byte[8];
for (b = 0; b != 8; ++b)
{
buffer[b] = bytes[offset++];
}
if (!le)
{
Array.Reverse(buffer);
}
field.DWORD64 = BitConverter.ToUInt64(buffer, 0);
break;
case FieldTypes.INT64:
if (!le)
{
Array.Reverse(buffer);
}
offset = FieldDataOffset + BitConverter.ToUInt32(buffer, 0);
buffer = new byte[8];
for (b = 0; b != 8; ++b)
{
buffer[b] = bytes[offset++];
}
if (!le)
{
Array.Reverse(buffer);
}
field.INT64 = BitConverter.ToInt64(buffer, 0);
break;
case FieldTypes.FLOAT:
if (!le)
{
Array.Reverse(buffer);
}
field.FLOAT = BitConverter.ToSingle(buffer, 0);
break;
case FieldTypes.DOUBLE:
if (!le)
{
Array.Reverse(buffer);
}
offset = FieldDataOffset + BitConverter.ToUInt32(buffer, 0);
buffer = new byte[8];
for (b = 0; b != 8; ++b)
{
buffer[b] = bytes[offset++];
}
if (!le)
{
Array.Reverse(buffer);
}
field.DOUBLE = BitConverter.ToDouble(buffer, 0);
break;
case FieldTypes.CResRef:
if (!le)
{
Array.Reverse(buffer);
}
offset = FieldDataOffset + BitConverter.ToUInt32(buffer, 0);
length = bytes[offset]; // 1-byte size
++offset;
buffer = new byte[(int)length];
for (b = 0; b != length; ++b)
{
buffer[b] = bytes[offset++];
}
field.CResRef = Encoding.ASCII.GetString(buffer, 0, buffer.Length);
break;
case FieldTypes.CExoString:
if (!le)
{
Array.Reverse(buffer);
}
offset = FieldDataOffset + BitConverter.ToUInt32(buffer, 0);
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[offset++];
}
if (!le)
{
Array.Reverse(buffer);
}
length = BitConverter.ToUInt32(buffer, 0); // 4-byte size
buffer = new byte[(int)length];
for (b = 0; b != length; ++b)
{
buffer[b] = bytes[offset++];
}
field.CExoString = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
field.CExoString = field.CExoString.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\n", "\r\n");
break;
case FieldTypes.CExoLocString:
if (!le)
{
Array.Reverse(buffer);
}
offset = FieldDataOffset + BitConverter.ToUInt32(buffer, 0);
buffer = new byte[4]; // total length (not incl/ these 4 bytes) ->
for (b = 0; b != 4; ++b) // aka Pointless. just advance the offset val
{
buffer[b] = bytes[offset++];
}
if (!le)
{
Array.Reverse(buffer);
}
length = BitConverter.ToUInt32(buffer, 0); // 4-byte size
buffer = new byte[4]; // strref (-1 no strref)
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[offset++];
}
if (!le)
{
Array.Reverse(buffer);
}
field.CExoLocStrref = BitConverter.ToUInt32(buffer, 0); // 4-byte size
buffer = new byte[4]; // substring count
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[offset++];
}
if (!le)
{
Array.Reverse(buffer);
}
count = BitConverter.ToUInt32(buffer, 0); // 4-byte size
if (count != 0)
{
field.Locales = new List <GffData.Locale>();
//logfile.Log("label= " + field.label);
for (j = 0; j != count; ++j)
{
var locale = new GffData.Locale();
buffer = new byte[4]; // langid
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[offset++];
}
if (!le)
{
Array.Reverse(buffer);
}
locale.SetLocaleLanguage(BitConverter.ToUInt32(buffer, 0));
buffer = new byte[4]; // stringlength
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[offset++];
}
if (!le)
{
Array.Reverse(buffer);
}
length = BitConverter.ToUInt32(buffer, 0);
//logfile.Log("length= " + length);
buffer = new byte[(int)length];
for (b = 0; b != length; ++b)
{
buffer[b] = bytes[offset++];
}
locale.local = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
locale.local = locale.local.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\n", "\r\n");
//logfile.Log("local= " + locale.local);
field.Locales.Add(locale);
}
}
break;
case FieldTypes.VOID:
if (!le)
{
Array.Reverse(buffer);
}
offset = FieldDataOffset + BitConverter.ToUInt32(buffer, 0);
buffer = new byte[4];
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[offset++];
}
if (!le)
{
Array.Reverse(buffer);
}
length = BitConverter.ToUInt32(buffer, 0);
field.VOID = new byte[(int)length];
for (j = 0; j != length; ++j)
{
field.VOID[j] = bytes[offset++];
}
break;
case FieldTypes.List: // a list-type Field is an offset into the FieldIndices; the later contains a list of StructIds.
if (!le)
{
Array.Reverse(buffer);
}
offset = ListIndicesOffset + BitConverter.ToUInt32(buffer, 0); // offset into the (not)FieldIndices(not) -> try ListIndices
buffer = new byte[4]; // 4-byte DWORD - count of structids
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[offset++];
}
if (!le)
{
Array.Reverse(buffer);
}
count = BitConverter.ToUInt32(buffer, 0);
var list = new List <uint>();
for (j = 0; j != count; ++j)
{
buffer = new byte[4]; // 4-byte DWORD - structid
for (b = 0; b != 4; ++b)
{
buffer[b] = bytes[offset++];
}
if (!le)
{
Array.Reverse(buffer);
}
list.Add(BitConverter.ToUInt32(buffer, 0));
}
field.List = list;
break;
case FieldTypes.Struct:
if (!le)
{
Array.Reverse(buffer);
}
field.Struct = Structs[(int)BitConverter.ToUInt32(buffer, 0)]; // NOTE: That is an id into the Structs not an offset.
break;
}
Fields.Add(field);
}
return(data);
}
FileService.error("That file has no data.");
}
return(null);
}
public void OnVisitSyntaxNode(GeneratorSyntaxContext context)
{
if (context.Node is not StructDeclarationSyntax sds)
{
return;
}
var methods = sds.ChildNodes().OfType <MethodDeclarationSyntax>().Where(m =>
{
var sm = (IMethodSymbol)context.SemanticModel.GetDeclaredSymbol(m);
return(sm != null && sm.GetAttributes()
.Any(a => a.AttributeClass?.Name == "MemberFunctionAttribute" || a.AttributeClass?.Name == "VirtualFunctionAttribute"));
}).ToList();
if (methods.Count > 0)
{
if (context.SemanticModel.GetDeclaredSymbol(sds) is not INamedTypeSymbol structType)
{
return;
}
var structObj = new Struct
{
Name = structType.Name,
Namespace = structType.ContainingNamespace.ToDisplayString(),
MemberFunctions = new List <Function>(),
VirtualFunctions = new List <Function>()
};
foreach (var m in methods)
{
if (context.SemanticModel.GetDeclaredSymbol(m) is not IMethodSymbol ms)
{
continue;
}
var format = new SymbolDisplayFormat(
typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces,
miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
var functionObj = new Function
{
Name = ms.Name,
ReturnType = ms.ReturnType.ToDisplayString(format),
HasReturn = ms.ReturnType.ToDisplayString() != "void",
HasParams = ms.Parameters.Any(),
ParamList = string.Join(",",
ms.Parameters.Select(p => $"{p.Type.ToDisplayString(format)} {p.Name}")),
ParamTypeList = string.Join(",", ms.Parameters.Select(p => p.Type.ToDisplayString(format))),
ParamNameList = string.Join(",", ms.Parameters.Select(p => p.Name))
};
if (ms.GetAttributes().FirstOrDefault(a => a.AttributeClass?.Name == "MemberFunctionAttribute") is { } memberFuncAttr)
{
functionObj.Signature = (string)memberFuncAttr.ConstructorArguments[0].Value;
functionObj.IsStatic = memberFuncAttr.NamedArguments.Any() ? (bool)memberFuncAttr.NamedArguments[0].Value.Value : false;
structObj.MemberFunctions.Add(functionObj);
}
if (ms.GetAttributes().FirstOrDefault(a => a.AttributeClass?.Name == "VirtualFunctionAttribute") is { } virtualFuncAttr)
{
functionObj.VirtualOffset = (int)virtualFuncAttr.ConstructorArguments[0].Value;
structObj.VirtualFunctions.Add(functionObj);
}
}
Structs.Add(structObj);
}
}
public void Process()
{
Content = System.IO.File.ReadAllText(File);
Content = Content.Trim();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < Content.Length; i++)
{
char c = Content[i];
// 字符解析获取语法
string sSymbol = string.Empty;
if (c == '#')
{
isComment = true;
}
if (c == '\n')
{
isComment = false;
}
if (isComment)
{
sb.Append(c);
}
else
{
if (c == '\n')
{
sSymbol = sb.ToString();
}
else if (c == ' ')
{
sSymbol = sb.ToString();
}
else if (c == '\t')
{
sSymbol = sb.ToString();
}
else
{
sb.Append(c);
}
}
// 确保当完成所有字符读取后可以生成字符表
if (i == Content.Length - 1)
{
sSymbol = sb.ToString();
}
if (!string.IsNullOrEmpty(sSymbol))
{
Symbols.Add(sSymbol);
sb.Clear();
}
if (c == '\n' || c == '\t')
{
Symbols.Add(c.ToString());
}
}
for (Index = 0; Index < Symbols.Count; Index++)
{
string symbol = Symbols[Index];
if (symbol == "\n")
{
Row = Row + 1;
}
if (symbol == "\n")
{
indentation = 0;
}
// 计算首行缩进
while (symbol == "\n")
{
Index = Index + 1;
if (Index == Symbols.Count - 1)
{
break;
}
string indent = Symbols[Index];
if (indent == "\t")
{
indentation++;
}
else
{
break;
}
}
symbol = Symbols[Index];
if (indentation == 0)
{
if (symbol == "struct")
{
define = Define.Struct;
Structs.Add(new TStruct());
Structs.Last().Name = GetSName();
Structs.Last().Comment = GetComment();
}
}
if (indentation == 1)
{
if (!string.IsNullOrEmpty(symbol))
{
// 首行缩进为1如果有不为空的字符则代表不处于内部结构中
if (define == Define.InStruct)
{
define = Define.Struct;
}
}
// 跳过直接换行
if (symbol == "\r")
{
continue;
}
if (symbol == "\n")
{
continue;
}
if (symbol == "struct")
{
if (Structs.Last() != null)
{
define = Define.InStruct;
Structs.Last().CStructs.Add(new TStruct());
Structs.Last().CStructs.Last().Name = GetSName();
Structs.Last().CStructs.Last().Comment = GetComment();
}
else
{
throw new Exception(ErrorMessage("首行缩进为1的语法定义为内部嵌套结构, 子结构需要定义在父结构内!"));
}
}
else
{
int cIndex = Index;
TField tField = new TField()
{
Type = GetSType(), Name = GetSName(), Comment = GetComment()
};
Structs.Last().Fields.Add(tField);
}
}
if (indentation == 2)
{
// 跳过直接换行
if (symbol == "\r")
{
continue;
}
if (symbol == "\n")
{
continue;
}
if (define == Define.InStruct)
{
if (symbol == "struct")
{
throw new Exception(ErrorMessage("内部结构不能在套内部结构!"));
}
TField tField = new TField()
{
Type = GetSType(), Name = GetSName(), Comment = GetComment()
};
Structs.Last().CStructs.Last().Fields.Add(tField);
}
else
{
throw new Exception(ErrorMessage("首行缩进为2的语法定义要求包含在内部结构中!"));
}
}
}
}
void LoadTypes(XmlNode root)
{
foreach (XmlNode node in root.ChildNodes)
{
if (node is XmlComment)
{
continue;
}
if (node.Attributes["requires"] != null && node.ChildNodes.Count == 0)
{
}
if (node.Attributes["category"] != null)
{
string cat = node.Attributes["category"].Value;
if (cat == "union" || cat == "struct")
{
string name = node.Attributes["name"].Value;
bool union = cat == "union";
List <Field> fields = new List <Field>();
foreach (XmlNode fNode in node.ChildNodes)
{
if (fNode is XmlComment)
{
continue;
}
if (fNode.Name == "comment")
{
continue;
}
if (fNode.Name == "validity")
{
continue;
}
LoadField(fNode, fields);
}
var s = new Struct(name, fields, union);
Structs.Add(s);
StructMap.Add(name, s);
}
else if (cat == "handle")
{
if (node.Attributes["alias"] != null)
{
continue;
}
string name = node["name"].InnerText;
List <Field> fields = new List <Field>();
var s = new Struct(name, fields, false);
s.Handle = true;
if (node["type"].InnerText == "VK_DEFINE_HANDLE")
{
fields.Add(new Field("native", "IntPtr", false, null));
}
else
{
fields.Add(new Field("native", "ulong", false, null));
}
Structs.Add(s);
StructMap.Add(name, s);
}
else if (cat == "enum")
{
if (node.Attributes["alias"] != null)
{
continue;
}
var eName = node.Attributes["name"].Value;
if (!EnumMap.ContainsKey(eName))
{
var e = new Enum(eName, false);
EnumMap.Add(eName, e);
Enums.Add(e);
AllEnums.Add(eName);
}
}
else if (cat == "bitmask")
{
if (node.Attributes["alias"] != null)
{
continue;
}
var eName = node["name"].InnerText;
if (!EnumMap.ContainsKey(eName))
{
var e = new Enum(eName, true);
EnumMap.Add(eName, e);
Enums.Add(e);
AllEnums.Add(eName);
}
}
}
}
}
