Add files via upload

Author: arrsoft312

xLoader2/DataBuffer.cs

@@ -0,0 +1,55 @@
+using System;
+
+struct DataBuffer {
+    private byte[] hexStringM;
+    
+    public int Size {
+        get { return hexStringM.Length; }
+    }
+    
+    public byte this[int index] {
+        get { return hexStringM[index]; }
+    }
+    
+    public byte[] ToByteArray(int startIndex = 0, int length = -1) {
+        if (length < 0) {
+            length = hexStringM.Length;
+        }
+        
+        byte[] array = new byte[length];
+        for (int i = 0; i < length; i++) {
+            array[i] = hexStringM[startIndex+i];
+        }
+        
+        return array;
+    }
+    
+    static public implicit operator DataBuffer(string text) {
+        return new DataBuffer(text);
+    }
+    
+    public DataBuffer(string text) {
+        int length = text.Length;
+        
+        hexStringM = new byte[length/2];
+        
+        for (int i = 0; i < length; i++) {
+            int c = text[i];
+            if (c >= 'A' && c <= 'F') {
+                c -= ('A'-10);
+            } else if (c >= 'a' && c <= 'f') {
+                c -= ('a'-10);
+            } else if (c >= '0' && c <= '9') {
+                c -= '0';
+            } else {
+                throw new FormatException("Could not find any recognizable digits.");
+            }
+            
+            if ((i % 2) == 0) {
+                hexStringM[i/2] = (byte)(c << 4);
+            } else {
+                hexStringM[i/2] |= (byte)c;
+            }
+        }
+    }
+}

xLoader2/MemoryChunk.cs

@@ -0,0 +1,32 @@
+using System;
+
+struct MemoryChunk {
+    private byte[] hexStringM;
+    private int addressM;
+    
+    public int StartAddress {
+        get { return addressM; }
+    }
+    public int EndAddress {
+        get { return (addressM + hexStringM.Length - 1); }
+    }
+    
+    public byte this[int addr] {
+        get { return hexStringM[addr-addressM]; }
+    }
+    
+    public bool In(int addr) {
+        return (addr >= addressM && addr < (addressM + hexStringM.Length));
+    }
+    
+    public MemoryChunk(int addr, byte[] array) {
+        int length = array.Length;
+        
+        hexStringM = new byte[length];
+        addressM = addr;
+        
+        for (int i = 0; i < length; i++) {
+            hexStringM[i] = array[i];
+        }
+    }
+}

xLoader2/MemoryMap.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+class MemoryMap {
+    private List<MemoryChunk> memoryChunkVector = new List<MemoryChunk>();
+    private int loLimitM = 0x7FFFFFFF;
+    private int hiLimitM = 0x00000000;
+    
+    //public int LowestAddress {
+        //get { return loLimitM; }
+    //}
+    //public int HighestAddress {
+        //get { return hiLimitM; }
+    //}
+    public int Size {
+        get { return (hiLimitM-loLimitM+1); }
+    }
+    
+    public byte this[int index] {
+        get
+        {
+            int addr = (loLimitM+index);
+            foreach (MemoryChunk chunk in memoryChunkVector) {
+                if (chunk.In(addr)) {
+                    return chunk[addr];
+                }
+            }
+            return 0xFF;
+        }
+    }
+    
+    public MemoryMap(string filename) {
+        StreamReader inFile;
+        try {
+            inFile = new StreamReader(filename, Encoding.ASCII, false);
+        } catch {
+            throw new Exception("Couldn't find '" + filename + "'.");
+        }
+        
+        try {
+            int highAddress = 0;
+            while (!inFile.EndOfStream) {
+                string s = inFile.ReadLine();
+                if (s == "") {
+                    continue;
+                }
+                if (s[0] != ':') {
+                    throw new Exception("'" + filename + "' is not an Intel HEX formatted file.");
+                }
+                
+                DataBuffer line = s.Remove(0, 1);
+                
+                byte chksum = 0;
+                for (int i = (line.Size-1); i >= 0; i--) {
+                    chksum += line[i];
+                }
+                
+                if (chksum != 0) {
+                    throw new Exception("'" + filename + "' is damaged.");
+                }
+                
+                byte length = line[0];
+                int address = ((line[1] << 8) | line[2]);
+                byte type = line[3];
+                
+                switch (type) {
+                    case 0:
+                    MemoryChunk chunk = new MemoryChunk((highAddress+address), line.ToByteArray(4, length));
+                    for (int i = chunk.StartAddress; i <= chunk.EndAddress; i++) {
+                        foreach (MemoryChunk chunk2 in memoryChunkVector) {
+                            if (chunk2.In(i)) {
+                                throw new Exception("Overlapping memory assignments in file '" + filename + "'.");
+                            }
+                        }
+                    }
+                    memoryChunkVector.Add(chunk);
+                    if (loLimitM > chunk.StartAddress) {
+                        loLimitM = chunk.StartAddress;
+                    }
+                    if (hiLimitM < chunk.EndAddress) {
+                        hiLimitM = chunk.EndAddress;
+                    }
+                    break;
+                    
+                    case 1: return;
+                    case 2: highAddress = ((line[4] << 12) | (line[5] << 4)); break;
+                    case 3: break;
+                    case 4: highAddress = ((line[4] << 24) | (line[5] << 16)); break;
+                    case 5: break;
+                    default: throw new Exception("'" + filename + "' is damaged.");
+                }
+            }
+        } finally {
+            inFile.Close();
+        }
+    }
+}