string FormatEnum(ref tag_field field, List <string> options, Type baseType, ActionRef <int> incrementMethod, bool isFlags = false) { StringWriter stringWriter = new StringWriter(); Dictionary <string, int> optionDictionary = new Dictionary <string, int>(); var baseTypeString = FormatTypeReference(baseType); if (isFlags) { stringWriter.WriteLine("[Flags]"); } stringWriter.WriteLine(string.Format("public enum {0} : {1}", ToTypeName(field.Name), baseTypeString)); stringWriter.WriteLine('{'); var index = isFlags ? 1 : 0; foreach (string option in options) { if (option != string.Empty) { stringWriter.WriteLine("{0} = {1},", ProcessFieldName(ToTypeName(option), optionDictionary), index); } incrementMethod(ref index); } stringWriter.WriteLine("}"); return(stringWriter.ToString()); }
public static T ReadFieldDefinition <T>(this BinaryReader reader, tag_field field) where T : IReadDefinition, new() { // Seek to the tag_block_definition address. reader.BaseStream.Position = field.definition - Guerilla.BaseAddress; return(ReadFieldDefinition <T>(reader)); }
string GetBinaryReaderMethodName(tag_field field) { var method = (from m in Methods where m.Key == valueTypeDictionary[field.type] where m.Value.ToLower().Contains(valueTypeDictionary[field.type].Name.Split('.').Last().ToLower()) select m).First(); return(method.Value); }
private void WriteTagBlockIndex(XmlWriter writer, tag_field field) { writer.WriteStartElement("byte"); writer.WriteAttributeString("name", field.Name + "-index?"); writer.WriteEndElement(); writer.WriteStartElement("byte"); writer.WriteAttributeString("name", field.Name + "-data?"); writer.WriteEndElement(); }
private void ProcessArrayFields(TagBlockDefinition 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 }
void WritePaddingField(StringWriter writer, ref tag_field field, Dictionary <string, int> fieldNames, out string fieldName, int paddingLength, bool isSkip = false) { var postFix = ProcessFieldName(ToMemberName(field.Name), fieldNames); var token = "invalidName_"; postFix = postFix.Contains(token) ? postFix.Remove(postFix.IndexOf(token), token.Length) : postFix; var paddingType = (isSkip ? "skip" : "padding"); fieldName = paddingType + postFix; var fieldType = "byte"; writer.WriteLine(@"#region {0}", paddingType); WriteFieldValArray(writer, paddingLength, fieldName, fieldType, true); writer.WriteLine(@"#endregion"); }
public static List <tag_field> ReadFields(this BinaryReader reader) { var fields = new List <tag_field>(); var field = new tag_field(); do { long currentAddress = reader.BaseStream.Position; field = reader.ReadFieldDefinition <tag_field>(); fields.Add(field); // Seek to the next tag_field. reader.BaseStream.Position = currentAddress + 16; } while (field.type != field_type._field_terminator); return(fields); }
private void WriteField(XmlWriter writer, tag_field field, int fieldOffset) { var count = 0; string[] postfixes; var typeString = FormatTypeString(ref field, out count, out postfixes).ToLower(); var fieldName = field.Name == string.Empty ? field.group_tag.ToString() : field.Name; if (count > 1) { for (int i = 0; i < count; ++i) { WriteField(writer, typeString, fieldName + ":" + postfixes[i], fieldOffset); } } else { WriteField(writer, typeString, fieldName, fieldOffset); } }
public static int CalculateSizeOfField(tag_field field) { switch (field.type) { case field_type._field_struct: { tag_struct_definition struct_definition = (tag_struct_definition)field.Definition; TagBlockDefinition blockDefinition = struct_definition.Definition; return(CalculateSizeOfFieldSet(blockDefinition.LatestFieldSet.Fields)); } case field_type._field_skip: case field_type._field_pad: return(field.definition); default: return(GetFieldSize(field.type)); } }
private void WriteEnumElement(XmlWriter writer, ref tag_field field, int fieldOffset, List <string> options, Type baseType, ActionRef <int> incrementMethod, bool isFlags = false) { Dictionary <string, int> optionDictionary = new Dictionary <string, int>(); var baseTypeString = FormatEnumReference(baseType, isFlags); string name, description; SplitNameDescription(field.Name, out name, out description); writer.WriteStartElement(baseTypeString); writer.WriteAttributeString("name", Format(name)); if (!string.IsNullOrEmpty(description)) { writer.WriteAttributeString("description", description); } writer.WriteAttributeString("offset", fieldOffset.ToString()); var index = isFlags ? 0 : 0; foreach (string option in options) { if (option != string.Empty) { SplitNameDescription(option, out name, out description); writer.WriteStartElement("option"); writer.WriteAttributeString("name", Format(name)); if (!string.IsNullOrEmpty(description)) { writer.WriteAttributeString("description", description); } writer.WriteAttributeString("value", index.ToString()); writer.WriteEndElement(); } incrementMethod(ref index); } writer.WriteEndElement(); }
string ReadEnum(ref tag_field field) { switch (field.type) { case field_type._field_byte_flags: return(FormatEnum(ref field, field.Definition.Options, typeof(byte), new ActionRef <int>(IncrementFlags), true)); case field_type._field_word_flags: return(FormatEnum(ref field, field.Definition.Options, typeof(short), new ActionRef <int>(IncrementFlags), true)); case field_type._field_long_flags: return(FormatEnum(ref field, field.Definition.Options, typeof(int), new ActionRef <int>(IncrementFlags), true)); case field_type._field_char_enum: return(FormatEnum(ref field, field.Definition.Options, typeof(byte), new ActionRef <int>(IncrementEnum))); case field_type._field_enum: return(FormatEnum(ref field, field.Definition.Options, typeof(short), new ActionRef <int>(IncrementEnum))); case field_type._field_long_enum: return(FormatEnum(ref field, field.Definition.Options, typeof(int), new ActionRef <int>(IncrementEnum))); } throw new InvalidDataException(); }
void WriteFieldValArray(StringWriter writer, ref tag_field field, Dictionary <string, int> fieldNames, out string fieldName, out string fieldType, int arrayLength, bool isSkip = false) { fieldName = ProcessFieldName(ToMemberName(field.Name), fieldNames); fieldType = ToTypeName(field.Name); WriteFieldValArray(writer, arrayLength, fieldName, fieldType); }
private void WriteField(StringWriter writer, tag_field field, Dictionary<string, int> fieldNames, out string fieldName, out string fieldType, string attributeString = "") { fieldType = FormatTypeString(ref field); fieldName = ProcessFieldName(ToMemberName(field.Name), fieldNames); WriteField(writer, fieldType, fieldName, attributeString); }
private string ReadEnum(ref tag_field field) { switch (field.type) { case field_type._field_byte_flags: return FormatEnum(ref field, field.Definition.Options, typeof(byte), new ActionRef<int>(IncrementFlags), true); case field_type._field_word_flags: return FormatEnum(ref field, field.Definition.Options, typeof(short), new ActionRef<int>(IncrementFlags), true); case field_type._field_long_flags: return FormatEnum(ref field, field.Definition.Options, typeof(int), new ActionRef<int>(IncrementFlags), true); case field_type._field_char_enum: return FormatEnum(ref field, field.Definition.Options, typeof(byte), new ActionRef<int>(IncrementEnum)); case field_type._field_enum: return FormatEnum(ref field, field.Definition.Options, typeof(short), new ActionRef<int>(IncrementEnum)); case field_type._field_long_enum: return FormatEnum(ref field, field.Definition.Options, typeof(int), new ActionRef<int>(IncrementEnum)); } throw new InvalidDataException(); }
protected virtual string ResolveFieldName(ref tag_field field, string fallbackFieldName) { var fieldName = ToMemberName(field.Name); return fieldName == "invalidName_" ? fallbackFieldName : fieldName; }
private void ProcessArrayFields(IList<tag_field> fields, ElementArray elementArray, 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(fields, elementArray, ref startindex, ref offset); } ++i; // move past field_type._field_array_end }
private void WriteEnumElement(XmlWriter writer, ref tag_field field, int fieldOffset, List<string> options, Type baseType, ActionRef<int> incrementMethod, bool isFlags = false) { Dictionary<string, int> optionDictionary = new Dictionary<string, int>(); var baseTypeString = FormatEnumReference(baseType, isFlags); string name, description; SplitNameDescription(field.Name, out name, out description); writer.WriteStartElement(baseTypeString); writer.WriteAttributeString("name", Format(name)); if (!string.IsNullOrEmpty(description)) writer.WriteAttributeString("description", description); writer.WriteAttributeString("offset", fieldOffset.ToString()); var index = isFlags ? 0 : 0; foreach (string option in options) { if (option != string.Empty) { SplitNameDescription(option, out name, out description); writer.WriteStartElement("option"); writer.WriteAttributeString("name", Format(name)); if (!string.IsNullOrEmpty(description)) writer.WriteAttributeString("description", description); writer.WriteAttributeString("value", index.ToString()); writer.WriteEndElement(); } incrementMethod(ref index); } writer.WriteEndElement(); }
protected override string FormatTypeString(ref tag_field field) { var csType = valueTypeDictionary[field.type]; return FormatTypeReference(csType); }
private string FormatTypeString(ref tag_field field, out int count, out string[] postfixes) { var type = valueTypeDictionary[field.type]; count = type.Item2; postfixes = new string[count]; var typeName = FormatTypeReference(type.Item1); switch (field.type) { case field_type._field_angle_bounds: case field_type._field_real_fraction_bounds: case field_type._field_short_bounds: case field_type._field_real_bounds: { postfixes = new string[] { "min", "max" }; } break; case field_type._field_argb_color: case field_type._field_real_argb_color: { postfixes = new string[] { "alpha", "red", "green", "blue" }; } break; case field_type._field_real_rgb_color: case field_type._field_rgb_color: { postfixes = new string[] { "red", "green", "blue" }; } break; case field_type._field_real_vector_3d: case field_type._field_real_point_3d: { postfixes = new string[] { "x", "y", "z" }; } break; case field_type._field_real_point_2d: case field_type._field_real_vector_2d: case field_type._field_point_2d: { postfixes = new string[] { "x", "y", }; } break; case field_type._field_real_euler_angles_2d: { postfixes = new string[] { "pitch", "roll" }; } break; case field_type._field_real_euler_angles_3d: { postfixes = new string[] { "pitch", "roll", "yaw" }; } break; case field_type._field_real_quaternion: { postfixes = new string[] { "i", "j", "k", "w" }; } break; default: break; } return typeName; }
private void WriteEnumElement(XmlWriter writer, enum_definition enumDefinition, ref tag_field field, int fieldOffset) { switch (field.type) { case field_type._field_byte_flags: WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(byte), new ActionRef<int>(IncrementFlags), true); break; case field_type._field_word_flags: WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(short), new ActionRef<int>(IncrementFlags), true); break; case field_type._field_long_flags: WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(int), new ActionRef<int>(IncrementFlags), true); break; case field_type._field_char_enum: WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(byte), new ActionRef<int>(IncrementEnum)); break; case field_type._field_enum: WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(short), new ActionRef<int>(IncrementEnum)); break; case field_type._field_long_enum: WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(int), new ActionRef<int>(IncrementEnum)); break; } }
protected override string ResolveFieldName(ref tag_field field, string fallbackFieldName) { var fieldName = ToMemberName(field.Name); return fieldName == string.Empty ? fallbackFieldName : fieldName; }
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 }
void WriteField(StringWriter writer, tag_field field, Dictionary <string, int> fieldNames, out string fieldName, out string fieldType, string attributeString = "") { fieldType = FormatTypeString(ref field); fieldName = ProcessFieldName(ToMemberName(field.Name), fieldNames); WriteField(writer, fieldType, fieldName, attributeString); }
private void WritePaddingField(StringWriter writer, ref tag_field field, Dictionary<string, int> fieldNames, out string fieldName, int paddingLength, bool isSkip = false) { var postFix = ProcessFieldName(ToMemberName(field.Name), fieldNames); var token = "invalidName_"; postFix = postFix.Contains(token) ? postFix.Remove(postFix.IndexOf(token), token.Length) : postFix; var paddingType = (isSkip ? "skip" : "padding"); fieldName = paddingType + postFix; var fieldType = "byte"; writer.WriteLine(@"#region {0}", paddingType); WriteFieldValArray(writer, paddingLength, fieldName, fieldType, true); writer.WriteLine(@"#endregion"); }
protected override string FormatTypeString(ref tag_field field) { var csType = valueTypeDictionary[field.type]; return(FormatTypeReference(csType)); }
public static List <tag_field> ReadFieldSet(this BinaryReader reader, ref TagBlockDefinition definition, out tag_field_set field_set) { field_set = new tag_field_set(); if (definition.Name == "sound_block") { definition.field_sets_address = 0x957870; //definition.field_set_latest_address = 0x906178; field_set.version.fields_address = 0x906178; field_set.version.index = 0; field_set.version.upgrade_proc = 0; field_set.version.size_of = -1; field_set.size = 172; field_set.alignment_bit = 0; field_set.parent_version_index = -1; field_set.fields_address = 0x906178; field_set.size_string_address = 0x00795330; field_set.size_string = "sizeof(sound_definition)"; } else { // We are going to use the latest tag_field_set for right now. if (definition.Name == "animation_pool_block") { reader.BaseStream.Position = definition.field_sets_address + ((definition.field_set_count - 2) * 76) - Guerilla.BaseAddress; } else if (definition.Name == "decorator_cache_block_data_block") { reader.BaseStream.Position = definition.field_sets_address + ((definition.field_set_count - 1) * 76) - Guerilla.BaseAddress; } else { reader.BaseStream.Position = definition.field_set_latest_address - Guerilla.BaseAddress; } field_set = reader.ReadFieldDefinition <tag_field_set>(); } // Seek to the field set address. reader.BaseStream.Position = field_set.fields_address - Guerilla.BaseAddress; var fields = new List <tag_field>(); var field = new tag_field(); do { long currentAddress = reader.BaseStream.Position; field = reader.ReadFieldDefinition <tag_field>(); fields.Add(field); // Seek to the next tag_field. reader.BaseStream.Position = currentAddress + 16;// sizeof(tag_field); }while (field.type != field_type._field_terminator); var blockName = definition.Name; var methods = (from method in Assembly.GetExecutingAssembly().GetTypes().SelectMany(x => x.GetMethods(BindingFlags.NonPublic | BindingFlags.Static)) where method.IsDefined(typeof(GuerillaPreProcessMethodAttribute), false) from attribute in method.GetCustomAttributes(typeof(GuerillaPreProcessMethodAttribute), false) where (attribute as GuerillaPreProcessMethodAttribute).BlockName == blockName select method).ToArray(); if (methods.Count() > 0) { methods[0].Invoke(null, new object[] { reader, fields }); } return(fields); }
private void WriteFieldValArray(StringWriter writer, ref tag_field field, Dictionary<string, int> fieldNames, out string fieldName, out string fieldType, int arrayLength, bool isSkip = false) { fieldName = ProcessFieldName(ToMemberName(field.Name), fieldNames); fieldType = ToTypeName(field.Name); WriteFieldValArray(writer, arrayLength, fieldName, fieldType); }
private string FormatEnum(ref tag_field field, List<string> options, Type baseType, ActionRef<int> incrementMethod, bool isFlags = false) { StringWriter stringWriter = new StringWriter(); Dictionary<string, int> optionDictionary = new Dictionary<string, int>(); var baseTypeString = FormatTypeReference(baseType); if (isFlags) stringWriter.WriteLine("[Flags]"); stringWriter.WriteLine(string.Format("public enum {0} : {1}", ToTypeName(field.Name), baseTypeString)); stringWriter.WriteLine('{'); var index = isFlags ? 1 : 0; foreach (string option in options) { if (option != string.Empty) { stringWriter.WriteLine("{0} = {1},", ProcessFieldName(ToTypeName(option), optionDictionary), index); } incrementMethod(ref index); } stringWriter.WriteLine("}"); return stringWriter.ToString(); }
private void WritePaddingField(StringWriter writer, ref tag_field field, Dictionary<string, int> fieldNames, out string fieldName, bool isSkip = false) { WritePaddingField(writer, ref field, fieldNames, out fieldName, field.definition, isSkip); }
protected virtual string FormatTypeString(ref tag_field field) { return(field.type.ToString()); }
private string GetBinaryReaderMethod(tag_field field) { var method = (from m in Methods where m.Key == valueTypeDictionary[field.type] where m.Value.ToLower().Contains(valueTypeDictionary[field.type].Name.Split('.').Last().ToLower()) select m).First(); return method.Value; }
private void WriteEnumElement(XmlWriter writer, enum_definition enumDefinition, ref tag_field field, int fieldOffset) { switch (field.type) { case field_type._field_byte_flags: WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(byte), new ActionRef <int>(IncrementFlags), true); break; case field_type._field_word_flags: WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(short), new ActionRef <int>(IncrementFlags), true); break; case field_type._field_long_flags: WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(int), new ActionRef <int>(IncrementFlags), true); break; case field_type._field_char_enum: WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(byte), new ActionRef <int>(IncrementEnum)); break; case field_type._field_enum: WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(short), new ActionRef <int>(IncrementEnum)); break; case field_type._field_long_enum: WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(int), new ActionRef <int>(IncrementEnum)); break; } }
public static int CalculateSizeOfField(tag_field field) { switch (field.type) { case field_type._field_struct: { tag_struct_definition struct_definition = (tag_struct_definition)field.Definition; tag_block_definition blockDefinition = struct_definition.Definition; return CalculateSizeOfFieldSet(blockDefinition.LatestFieldSet.Fields); } case field_type._field_skip: case field_type._field_pad: return field.definition; default: return GetFieldSize(field.type); } }
void WritePaddingField(StringWriter writer, ref tag_field field, Dictionary <string, int> fieldNames, out string fieldName, bool isSkip = false) { WritePaddingField(writer, ref field, fieldNames, out fieldName, field.definition, isSkip); }
protected virtual string FormatTypeString(ref tag_field field) { return field.type.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); }
protected virtual string ResolveFieldName(ref tag_field field, string fallbackFieldName) { var fieldName = ToMemberName(field.Name); return(fieldName == "invalidName_" ? fallbackFieldName : fieldName); }
protected override string ResolveFieldName(ref tag_field field, string fallbackFieldName) { var fieldName = ToMemberName(field.Name); return(fieldName == string.Empty ? fallbackFieldName : fieldName); }
private void ProcessArrayFields(IList <tag_field> fields, ElementArray elementArray, 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(fields, elementArray, ref startindex, ref offset); } ++i; // move past field_type._field_array_end }
private string FormatTypeString(ref tag_field field, out int count, out string[] postfixes) { var type = valueTypeDictionary[field.type]; count = type.Item2; postfixes = new string[count]; var typeName = FormatTypeReference(type.Item1); switch (field.type) { case field_type._field_angle_bounds: case field_type._field_real_fraction_bounds: case field_type._field_short_bounds: case field_type._field_real_bounds: { postfixes = new string[] { "min", "max" }; } break; case field_type._field_argb_color: case field_type._field_real_argb_color: { postfixes = new string[] { "alpha", "red", "green", "blue" }; } break; case field_type._field_real_rgb_color: case field_type._field_rgb_color: { postfixes = new string[] { "red", "green", "blue" }; } break; case field_type._field_real_vector_3d: case field_type._field_real_point_3d: { postfixes = new string[] { "x", "y", "z" }; } break; case field_type._field_real_point_2d: case field_type._field_real_vector_2d: case field_type._field_point_2d: { postfixes = new string[] { "x", "y", }; } break; case field_type._field_real_euler_angles_2d: { postfixes = new string[] { "pitch", "roll" }; } break; case field_type._field_real_euler_angles_3d: { postfixes = new string[] { "pitch", "roll", "yaw" }; } break; case field_type._field_real_quaternion: { postfixes = new string[] { "i", "j", "k", "w" }; } break; default: break; } return(typeName); }