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(); }