General code cleanup in reader class. Added stub methods for extracting data retrieval to a separate method.

BlendFile/Reader.cs

@@ -2,6 +2,7 @@ using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text;
 using Kaitai;
+using static Kaitai.BlendFile;
 
 
 namespace BlendFile;
@@ -10,7 +11,7 @@ public class Reader {
     string _path;
     private readonly Dictionary<int, Type> dnaTypes = new();
     private readonly Dictionary<string, Type> dnaTypesDb = new();
-    
+
     private Dictionary<(IntPtr, Type), object> objects = new();
     public Dictionary<(IntPtr, Type), object> Objects => objects;
 
@@ -22,19 +23,20 @@ public class Reader {
     /// Value: Memory address of the object we are pointing to
     /// </remarks>
     private Dictionary<IntPtr, IntPtr> pointers = new();
-    
+
     public List<object> GetObjects() => objects.Values.ToList();
     public List<T> GetObjects<T>() => objects.Values.OfType<T>().ToList();
-    
+
     private SortedDictionary<long, Kaitai.BlendFile.FileBlock> memBlocks = new();
-    
+
     /// <summary>
     /// Gets the block at the specified memory address
     /// </summary>
     /// <param name="memAddr">memory address in current system endianness</param>
     /// <returns>A <see cref="Kaitai.BlendFile.FileBlock"/> object</returns>
-    public Kaitai.BlendFile.FileBlock? GetBlock(long memAddr) => memBlocks.SkipWhile(x => x.Key < memAddr).FirstOrDefault().Value;
+    public FileBlock? GetBlock(long memAddr) =>
-    
+        memBlocks.SkipWhile(x => x.Key < memAddr).FirstOrDefault().Value;
+
     /// <summary>
     /// Creates a new instance of the <see cref="Reader"/> class
     /// </summary>
@@ -56,7 +58,7 @@ public class Reader {
             dnaTypesDb.Add(attrib.OriginalName, type);
         }
     }
-    
+
     public void Read(string path) {
         _path = path;
         Read();
@@ -65,9 +67,9 @@ public class Reader {
     public void Read() {
         var file = new KaitaiStream(_path);
         var blend = new Kaitai.BlendFile(file);
-        
+
         Console.WriteLine($"Start offset: 0x{blend.Blocks[0].MemAddr.ToPointer():X}");
-        
+
         bool isLe = blend.Hdr.Endian == Kaitai.BlendFile.Endian.Le;
         //TODO: two blocks somehow have the same mem address... this sounds wrong.
         blend.Blocks.ForEach(block => memBlocks.TryAdd(block.MemAddr.ToMemAddr(isLe), block));
@@ -76,11 +78,11 @@ public class Reader {
             //We need to read all blocks of data regardless of the type
             //Checks if the block has a known SDNA type, meaning that we know how it is structured 
             if (!dnaTypes.ContainsKey((int)block.SdnaIndex)) continue;
-            
+
             //Get the type of the block
             dnaTypesDb.TryGetValue(block.SdnaStruct.Type, out Type? t);
             if (t == null) continue; //should never happen
-            
+
             // How many objects are in the block
             var count = block.Count;
             //offset for the next object in the block
@@ -101,9 +103,10 @@ public class Reader {
         foreach (var obj in objects) {
             FieldInfo[] fieldInfo = obj.Value.GetType().GetFields();
             var list = fieldInfo.Where(fldInfo => fldInfo.GetCustomAttribute<DNAFieldAttribute>()!.IsPointer).ToList();
-            
+
-            foreach(var f in list) {
+            foreach (var f in list) {
-                var addr = GetBlockFieldDataOffset(obj.Key.Item1, f.GetCustomAttribute<DNAFieldAttribute>()!.OriginalIndex, fieldInfo);
+                var addr = GetBlockFieldDataOffset(obj.Key.Item1, f.GetCustomAttribute<DNAFieldAttribute>()!.OriginalIndex,
+                    fieldInfo);
                 var newobj = objects.GetValueOrDefault((addr, f.FieldType));
                 if (newobj != null) f.SetValue(obj.Value, newobj);
             }
@@ -111,11 +114,11 @@ public class Reader {
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private long GetBlockFieldDataOffset(long blockAddress, int fieldIndex, FieldInfo[] fieldMetadata) => 
+    private long GetBlockFieldDataOffset(long blockAddress, int fieldIndex, FieldInfo[] fieldMetadata) =>
         blockAddress + GetFieldDataOffset(fieldIndex, fieldMetadata);
-    
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private IntPtr GetBlockFieldDataOffset(IntPtr blockAddress, int fieldIndex, FieldInfo[] fieldMetadata) => 
+    private IntPtr GetBlockFieldDataOffset(IntPtr blockAddress, int fieldIndex, FieldInfo[] fieldMetadata) =>
         new(blockAddress + GetFieldDataOffset(fieldIndex, fieldMetadata));
 
     /// <summary>
@@ -128,15 +131,16 @@ public class Reader {
     private long GetFieldDataOffset(int fieldIndex, FieldInfo[] fieldMetadata) =>
         fieldMetadata.First(x => x.GetCustomAttribute<DNAFieldAttribute>()!.OriginalIndex == fieldIndex)
             .GetCustomAttribute<DNAFieldAttribute>()!.MemoryOffset;
-    
+
     /// <summary>
     /// Creates an instance of a given type
     /// </summary>
     /// <param name="type">A <see cref="string"/> containing the name of the type to create</param>
     /// <returns>An object of the type specified in the parameter or null</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private object? ActivateInstance(string type) => dnaTypesDb.TryGetValue(type, out Type? t) ? Activator.CreateInstance(t) : null;
+    private object? ActivateInstance(string type) =>
-    
+        dnaTypesDb.TryGetValue(type, out Type? t) ? Activator.CreateInstance(t) : null;
+
     /// <summary>
     /// Filles a given object with the data from a block, starting to read it from the specified offset
     /// </summary>
@@ -144,33 +148,37 @@ public class Reader {
     /// <param name="obj">object of same struct type as the one that is being decoded</param>
     /// <param name="fieldMetadata">Array of <see cref="FieldInfo"/>s containing <see cref="DNAFieldAttribute"/> attributes</param>
     /// <param name="startOffset">offset in bytes from where structure starts in the block</param>
-    private void FillObject(Kaitai.BlendFile.FileBlock block, ref object? obj, FieldInfo[] fieldMetadata, IntPtr startOffset = 0) {
+    private void FillObject(FileBlock block, ref object? obj, FieldInfo[] fieldMetadata,
-        if(block.Code == "ENDB") return;// ENDB is a special block that does not contain any data
+        IntPtr startOffset = 0) {
+        if (block.Code == "ENDB") return; // ENDB is a special block that does not contain any data
         foreach (var field in fieldMetadata) {
+            //object? value;
+
             //Get the DNAFieldAttribute of the current field
             var attrib = field.GetCustomAttribute<DNAFieldAttribute>();
             if (attrib == null) continue; //should never happen, but means a field has no metadata
-            
+
             //Calculate the offset from where the data of the field starts.
             //Because the order of the fields is not guaranteed we need to compute it each time
             IntPtr offset = attrib.MemoryOffset;
-            
+
             int size = attrib.Size;
             var data = new byte[size];
             Array.Copy((byte[])block.Body, offset, data, 0, size);
             //Convert the data to the correct type
             object? value = ConvertFieldData(data, attrib.OriginalType);
-            
+
-            if(value == null){ //if the data could not be converted
+            if (value == null) {
+                //if the data could not be converted
                 //Check if the field is a pointer to another DNA structure
                 if (dnaTypesDb.ContainsKey(attrib.OriginalType)) {
                     //Create a new instance of the DNA structure type
                     object? newObj = ActivateInstance(attrib.OriginalType);
-                    if(newObj == null) continue; //should never happen... type is missing?
+                    if (newObj == null) continue; //should never happen... type is missing?
-                    
+
                     //Get the information of the fields of the new object
                     var fieldInfo = newObj.GetType().GetFields();
-                    
+
                     //If the field is not a pointer, we need to dereference it
                     if (!attrib.IsPointer) {
                         IntPtr relAddr = block.MemAddr.ToPointer() + offset;
@@ -181,24 +189,40 @@ public class Reader {
                         }
                         //Fill the object with the data from the block (this is recursive)
                         FillObject(block, ref newObj, fieldInfo, offset);
-                    } else { // if is a pointer, make a pointer to the pointer
+                    } else {
+                        // if is a pointer, make a pointer to the pointer
                         IntPtr memAddr = data.ToPointer();
                         if (memAddr == 0) continue; //nullPointer, no need to store the reference
                         pointers.TryAdd(block.MemAddr.ToPointer() + offset, data.ToPointer());
                     }
                 }
-                continue; //should never happen, but means the data could not be converted
+                if (attrib == null) {
+                    //not a normal field
+                    var listAttrib = field.GetCustomAttribute<DNAListAttribute>();
+                    if (listAttrib == null) continue; //not a list field either, this should never happen...
+                    ConvertListField(); //Convert the list field
+                    continue;
+                }
+                value = ConvertNormalField(block, field, attrib);
+
+                //Additionally... some fields might not be nullable so it's better to not assign the value and leave the default one.
+                field.SetValue(obj, value);
             }
-            //Additionally... some fields might not be nullable so it's better to not assign the value and leave the default one.
+            objects.Add((block.MemAddr.ToPointer() + startOffset, obj!.GetType()), obj!);
-            field.SetValue(obj, value);
         }
         objects.Add((block.MemAddr.ToPointer() + startOffset, obj!.GetType()), obj!);
     }
-    
+
-    private object? ConvertFieldData(byte[] data, string type)
+    private object? ConvertNormalField(FileBlock block, FieldInfo field, DNAFieldAttribute attrib) {
-    {
+        return null;
-        return type switch
+    }
-        {
+
+    private object? ConvertListField(FileBlock block, FieldInfo field, DNAFieldAttribute attrib) {
+        return null;
+    }
+
+    private object? ConvertFieldData(byte[] data, string type) {
+        return type switch {
             "char" => (char)data[0],
             "short" => BitConverter.ToInt16(data, 0),
             "int" => BitConverter.ToInt32(data, 0),