public void Read(IntPtr h2LangLib, BinaryReader reader)
{
this = new tag_block_definition(reader);
}
private ElementArray ProcessTagBlockDefinition(ElementArray parent, tag_block_definition tagBlock, ref int offset, bool inline = false, string group_tag = "")
{
var size = Guerilla.CalculateSizeOfFieldSet(tagBlock.LatestFieldSet.Fields);
var blockElementArray = new ElementArray()
{
Name = tagBlock.Name,
ElementSize = size,
Address = offset,
Parent = parent,
MaxElementCount = tagBlock.maximum_element_count,
Alignment = tagBlock.LatestFieldSet.Alignment,
};
var i = 0;
int blockOffset = inline ? offset : 0;
ProcessFields(tagBlock.LatestFieldSet.Fields, blockElementArray, ref i, ref blockOffset);
if (inline) offset = blockOffset;
return blockElementArray;
}
private IEnumerable<ElementArray> ProcessTagStructDefinition(ElementArray parent, tag_block_definition definition, ref int offset)
{
var size = Guerilla.CalculateSizeOfFieldSet(definition.LatestFieldSet.Fields);
var blockElementArray = new ElementArray()
{
Name = definition.Name,
ElementSize = size,
Address = offset,
Parent = parent,
MaxElementCount = definition.maximum_element_count,
Alignment = definition.LatestFieldSet.Alignment,
};
var i = 0;
ProcessFields(definition.LatestFieldSet.Fields, blockElementArray, ref i, ref offset);
return blockElementArray.Children;
}
private void ProcessArrayFields(tag_block_definition definition, XmlWriter writer, IList<tag_field> fields, ref tag_field field, ref int i, ref int offset)
{
var name = field.Name;
++i; //move past field_type._field_array_start
for (int index = 0; index < field.definition; ++index)
{
int startindex = i;
ProcessFields(definition, writer, fields, ref startindex, ref offset);
}
++i; // move past field_type._field_array_end
}
private ElementArray ProcessTagBlockDefinition(tag_block_definition tagBlock, ref int offset, bool inline = false)
{
return ProcessTagBlockDefinition(null, tagBlock, ref offset, inline, "");
}
private void ProcessFields(tag_block_definition tagBlock, XmlWriter writer, IList<tag_field> fields, ref int i, ref int fieldOffset)
{
writer.Flush();
for (; i < fields.Count; ++i)
{
var field = fields[i];
// Check the field type.
switch (field.type)
{
case field_type._field_tag_reference:
{
WriteField(writer, "tag", field.Name, fieldOffset + 0);
WriteField(writer, "id", field.Name, fieldOffset + 4);
break;
}
case field_type._field_block:
{
ProcessTagBlockDefinition(field.Definition, writer, field.definition, ref fieldOffset, "", field.Name);
break;
}
case field_type._field_struct:
{
tag_struct_definition struct_definition = (tag_struct_definition)field.Definition;
var fieldType = ToTypeName(struct_definition.name);
ProcessTagBlockDefinition(struct_definition.Definition, writer, struct_definition.block_definition_address, ref fieldOffset, "", field.Name, false, true);
break;
}
case field_type._field_data:
{
{
writer.WriteStartElement("struct");
writer.WriteAttributeString("name", field.Name);
writer.WriteAttributeString("offset", fieldOffset.ToString());
writer.WriteAttributeString("size", 1.ToString());
writer.WriteAttributeString("maxelements", ((tag_data_definition)field.Definition).maximumSize.ToString());
writer.WriteAttributeString("padalign", ((tag_data_definition)field.Definition).Alignment.ToString());
writer.WriteStartElement("byte");
writer.WriteAttributeString("name", "data");
writer.WriteAttributeString("offset", 1.ToString());
writer.WriteAttributeString("visible", "false");
writer.WriteEndElement();
writer.WriteEndElement();
}
break;
}
case field_type._field_explanation:
{
//// Check if there is sub-text for this explaination.
//string subtext = "";
//if (field.definition != 0)
// subtext = Guerilla.ReadString(reader, field.definition);
// Write the field info to the output file.
//writer.WriteComment(string.Format("FIELD_EXPLAINATION(\"{0}\", \"{1}\"),", field.Name, subtext.Replace("\n", "<lb>")));
break;
}
case field_type._field_byte_flags:
case field_type._field_long_flags:
case field_type._field_word_flags:
case field_type._field_char_enum:
case field_type._field_enum:
case field_type._field_long_enum:
{
WriteEnumElement(writer, field.Definition, ref field, fieldOffset);
break;
}
case field_type._field_byte_block_flags:
case field_type._field_word_block_flags:
case field_type._field_long_block_flags:
case field_type._field_char_block_index1:
case field_type._field_short_block_index1:
case field_type._field_long_block_index1:
{
WriteField(writer, field, fieldOffset);
break;
}
case field_type._field_char_block_index2:
case field_type._field_short_block_index2:
case field_type._field_long_block_index2:
{
WriteField(writer, field, fieldOffset);
break;
}
case field_type._field_array_start:
{
ProcessArrayFields(tagBlock, writer, fields, ref field, ref i, ref fieldOffset);
break;
}
case field_type._field_array_end:
{
return;
}
case field_type._field_string:
{
WriteField(writer, "string32", field.Name, fieldOffset + 0);
} break;
case field_type._field_long_string:
{
WriteField(writer, "string256", field.Name, fieldOffset + 0);
} break;
case field_type._field_pad:
{
WritePaddingField(writer, field.definition, fieldOffset, tagBlock.DisplayName);
break;
}
case field_type._field_skip:
{
WritePaddingField(writer, field.definition, fieldOffset);
break;
}
case field_type._field_useless_pad:
case field_type._field_terminator:
case field_type._field_custom:
{
break;
}
default:
{
//attributeString.Append("TagField");
WriteField(writer, field, fieldOffset);
break;
}
}
fieldOffset += CalculateSizeOfField(field);
}
}
private void ProcessTagBlockDefinition(tag_block_definition tagBlock, XmlWriter writer, int address, ref int fieldOffset, string group_tag = "", string className = "", bool root = false, bool inline = false, IList<tag_field> fieldOverride = null)
{
IList<tag_field> fields = tagBlock.LatestFieldSet.Fields;
if (fieldOverride != null)
{
fields = fieldOverride;
}
var size = CalculateSizeOfFieldSet(fields);
if (size == 0)
{
if (!inline)
{
WritePaddingField(writer, 8, fieldOffset);
}
return;
}
if (root)
{
writer.WriteStartDocument();
writer.WriteStartElement("plugin");
writer.WriteAttributeString("class", group_tag);
writer.WriteAttributeString("author", "Moonfish");
writer.WriteAttributeString("headersize", size.ToString());
}
else if (!inline)
{
writer.WriteStartElement("struct");
WriteNameAndDescriptionAttributes(writer, className == string.Empty ? tagBlock.DisplayName : className);
writer.WriteAttributeString("type", tagBlock.Name);
writer.WriteAttributeString("offset", fieldOffset.ToString());
writer.WriteAttributeString("size", size.ToString());
writer.WriteAttributeString("maxelements", tagBlock.maximum_element_count.ToString());
writer.WriteAttributeString("padalign", tagBlock.LatestFieldSet.Alignment.ToString());
writer.WriteAttributeString("visible", "false");
}
var i = 0;
var offset = !inline ? 0 : fieldOffset;
ProcessFields(tagBlock, writer, fields, ref i, ref offset);
// Finish the tag_field_set struct.
if (!inline)
{
writer.WriteEndElement();
}
}
public string ProcessTagBlockDefinition(tag_block_definition tagBlock, Dictionary<string, string> structDictionary, int address, string group_tag = "", string className = "", bool root = false)
{
//
StringWriter writer = new StringWriter();
var size = CalculateSizeOfFieldSet(tagBlock.LatestFieldSet.Fields);
// Write StructLayout attribute
writer.WriteLine(@"[StructLayout(LayoutKind.Sequential, Size = {0}, Pack = {1})]", size, tagBlock.LatestFieldSet.Alignment);
if (root) { writer.WriteLine(@"[TagClass(""{0}"")]", group_tag); }
//Write class declaration
writer.WriteLine(@"public partial {0} {1}", "class", className == string.Empty ? ToTypeName(tagBlock.Name) : className);
writer.WriteLine("{");
var i = 0;
string constructorBody, fieldDefinitions;
ProcessFields(tagBlock, structDictionary, writer, tagBlock.LatestFieldSet.Fields, ref i, out fieldDefinitions, out constructorBody);
writer.WriteLine("public {0}()", className == string.Empty ? ToTypeName(tagBlock.Name) : className);
writer.WriteLine("{");
writer.WriteLine("}");
writer.WriteLine("public {0}(BinaryReader binaryReader)", className == string.Empty ? ToTypeName(tagBlock.Name) : className);
writer.WriteLine("{");
writer.Write(constructorBody);
writer.WriteLine("}");
writer.Write(fieldDefinitions);
// Finish the tag_field_set struct.
writer.WriteLine("}");
//
return writer.ToString();
}
private void ProcessArrayFields(tag_block_definition definition, Dictionary<string, string> structDictionary,
StringWriter writer, List<tag_field> fields, ref tag_field field, ref int fieldIndex, Dictionary<string, int> fieldNames,
out string fieldName, out string fieldType)
{
fieldName = ToTypeName(field.Name);
writer.WriteLine("public struct {0}", fieldName);
writer.WriteLine("{");
var name = field.Name;
++fieldIndex;
string fieldDefinitions, constructorBody;
ProcessFields(definition, structDictionary, writer, fields, ref fieldIndex, out fieldDefinitions, out constructorBody);
writer.WriteLine("public {0}(BinaryReader binaryReader)", fieldName);
writer.WriteLine("{");
writer.Write(constructorBody);
writer.WriteLine("}");
writer.WriteLine("}");
WriteFieldValArray(writer, ref field, fieldNames, out fieldName, out fieldType, field.definition);
}
private void ProcessFields(tag_block_definition tagBlock, Dictionary<string, string> structDictionary, StringWriter writer, List<tag_field> fields, ref int i,
out string fieldDefinitions, out string constructorBody)
{
StringBuilder fieldDefinitionsBuilder = new StringBuilder();
StringBuilder constructorBodyBuilder = new StringBuilder();
Dictionary<string, int> fieldNames = new Dictionary<string, int>();
for (; i < fields.Count; ++i)
{
StringBuilder attributeString = new StringBuilder();
var field = fields[i];
// Check the field type.
switch (field.type)
{
case field_type._field_tag_reference:
{
attributeString.AppendFormat(@"TagReference(""{0}"")", GroupTagToString(field.Definition.group_tag));
string fieldName, fieldType;
WriteField(writer, field, fieldNames, out fieldName, out fieldType, attributeString.ToString());
constructorBodyBuilder.AppendLine(string.Format("this.{0} = binaryReader.Read{1}();", fieldName, fieldType));
break;
}
case field_type._field_block:
{
attributeString.Append("TagBlockField");
// Write the field
var fieldName = ProcessFieldName(ResolveFieldName(ref field, ToMemberName(field.Definition.DisplayName)), fieldNames);
var fieldType = ToTypeName(field.Definition.Name);
WriteField(writer, fieldType, fieldName, attributeString.ToString(), true);
constructorBodyBuilder.AppendLine(string.Format(@"{{
var elementSize = Marshal.SizeOf(typeof({0}));
var blamPointer = binaryReader.ReadBlamPointer(elementSize);
this.{1} = new {0}[blamPointer.Count];
using(binaryReader.BaseStream.Pin())
{{
for(int i = 0; i < blamPointer.Count; ++i)
{{
binaryReader.BaseStream.Position = blamPointer[i];
this.{1}[i] = new {0}(binaryReader);
}}
}}
}}", fieldType, fieldName));
if (!structDictionary.ContainsKey(field.Definition.Name))
{
structDictionary[field.Definition.Name] = ProcessTagBlockDefinition(field.Definition, structDictionary, field.definition);
}
break;
}
case field_type._field_struct:
{
attributeString.Append("TagStructField");
var fieldName = ProcessFieldName(ResolveFieldName(ref field, ToMemberName(field.Definition.displayName)), fieldNames);
var fieldType = ToTypeName(field.Definition.name);
WriteField(writer, fieldType, fieldName, attributeString.ToString());
constructorBodyBuilder.AppendLine(string.Format("this.{0} = new {1}(binaryReader);", fieldName, fieldType));
if (!structDictionary.ContainsKey(field.Definition.name))
{
structDictionary[field.Definition.name] = ProcessTagBlockDefinition(field.Definition.Definition, structDictionary, field.Definition.block_definition_address, "", fieldType);
}
break;
}
case field_type._field_data:
{
string fieldName;
WritePaddingField(writer, ref field, fieldNames, out fieldName, 8);
constructorBodyBuilder.AppendLine(string.Format("this.{0} = binaryReader.ReadBytes(8);",
fieldName));
break;
}
case field_type._field_explanation:
{
//// Check if there is sub-text for this explaination.
//string subtext = "";
//if (field.definition != 0)
// subtext = ReadString(reader, field.definition);
//// Write the field info to the output file.
//writer.WriteLine("//FIELD_EXPLAINATION(\"{0}\", \"{1}\"),", field.Name, subtext.Replace("\n", "<lb>"));
break;
}
case field_type._field_byte_flags:
case field_type._field_long_flags:
case field_type._field_word_flags:
case field_type._field_char_enum:
case field_type._field_enum:
case field_type._field_long_enum:
{
var enumString = ReadEnum(ref field);
fieldDefinitionsBuilder.Append(enumString);
string fieldName = ToMemberName(field.Name);
string fieldType = ToTypeName(field.Name);
WriteField(writer, fieldType, fieldName, attributeString.ToString());
string baseType;
switch (field.type)
{
case field_type._field_char_enum:
case field_type._field_byte_flags:
baseType = "Byte";
break;
case field_type._field_word_flags:
case field_type._field_enum:
baseType = "Int16";
break;
case field_type._field_long_flags:
case field_type._field_long_enum:
baseType = "Int32";
break;
default:
baseType = ""; break;
}
constructorBodyBuilder.AppendLine(string.Format("this.{0} = ({1})binaryReader.Read{2}();", fieldName, fieldType, baseType));
break;
}
case field_type._field_byte_block_flags:
case field_type._field_word_block_flags:
case field_type._field_long_block_flags:
case field_type._field_char_block_index1:
case field_type._field_short_block_index1:
case field_type._field_long_block_index1:
case field_type._field_char_block_index2:
case field_type._field_short_block_index2:
case field_type._field_long_block_index2:
{
string fieldName, fieldType;
WriteField(writer, field, fieldNames, out fieldName, out fieldType);
constructorBodyBuilder.AppendLine(string.Format("this.{0} = binaryReader.Read{1}();", fieldName, fieldType));
break;
}
case field_type._field_array_start:
{
string fieldName, fieldType;
ProcessArrayFields(tagBlock, structDictionary, writer, fields, ref field, ref i, fieldNames, out fieldName, out fieldType);
var count = field.definition;
constructorBodyBuilder.AppendLine(string.Format(
@"this.{0} = new {1}[{2}];
for(int i = 0 ; i < {2}; ++i)
{{
this.{0}[i] = new {1}(binaryReader);
}}", fieldName, fieldType, count));
break;
}
case field_type._field_array_end:
{
constructorBody = constructorBodyBuilder.ToString();
fieldDefinitions = fieldDefinitionsBuilder.ToString();
return;
}
case field_type._field_pad:
{
string fieldName;
WritePaddingField(writer, ref field, fieldNames, out fieldName);
constructorBodyBuilder.AppendLine(string.Format("this.{0} = binaryReader.Read{1};",
fieldName, field.definition == 1 ? "Byte()" : string.Format("Bytes({0})", field.definition)));
break;
}
case field_type._field_skip:
{
string fieldName;
WritePaddingField(writer, ref field, fieldNames, out fieldName, true);
constructorBodyBuilder.AppendLine(string.Format("this.{0} = binaryReader.Read{1};",
fieldName, field.definition == 1 ? "Byte()" : string.Format("Bytes({0})", field.definition)));
break;
}
case field_type._field_useless_pad:
case field_type._field_terminator:
case field_type._field_custom:
{
break;
}
default:
{
string fieldName, fieldType;
WriteField(writer, field, fieldNames, out fieldName, out fieldType, attributeString.ToString());
constructorBodyBuilder.AppendLine(string.Format("this.{0} = binaryReader.{1}();", fieldName, GetBinaryReaderMethod(field)));
break;
}
}
}
fieldDefinitions = fieldDefinitionsBuilder.ToString();
constructorBody = constructorBodyBuilder.ToString();
}
