Update to 1.2

Author: KodingBTW

decoder.py

@@ -153,12 +153,10 @@ def processPointers4Bytes(data, header):
         # Read four bytes as a quartet
         quartet = data[i:i + 4]
 
-        # Get last two byte of the quartet
-        get2Bytes = quartet[2:]
-        
         # Convert the final triplet to an integer
-        value = int.from_bytes(get2Bytes, byteorder='big') + header
+        value = int.from_bytes(quartet, byteorder='big') + header
         result.append(value)
+
     return result
 
 def extractTexts(romData, addressesList, lineBreakers, charTable):
@@ -187,13 +185,14 @@ def extractTexts(romData, addressesList, lineBreakers, charTable):
     # Loop over each starting address in the list
     for addr in addressesList:
         text = bytearray()
+        decodedValidCharacter = False
 
         while True:
             byte = romData[addr]  
             bytesLineCounter += 1
 
             # If the byte is a line-breaker, stop extracting
-            if byte in lineBreakers:
+            if byte in lineBreakers and decodedValidCharacter:
                 breakerByte = byte
                 break
 
@@ -203,10 +202,12 @@ def extractTexts(romData, addressesList, lineBreakers, charTable):
                 # If single character
                 if len(char) == 1:
                     text.append(ord(char))
+                    decodedValidCharacter = True
                 # If multiple characters (DTE/MTE)
                 else:  
                     for c in char:
                         text.append(ord(c))
+                    decodedValidCharacter = True
             # If byte is not in charTable, print in format ~hex~
             else:
                 hexValue = format(byte, '02X')
@@ -243,6 +244,76 @@ def extractTexts(romData, addressesList, lineBreakers, charTable):
 
     return texts, totalBytesRead, linesLength
 
+def extractTextsNoLineBreakers(romData, addressesList, endOffset, charTable):
+    """
+    Extracts texts from the ROM data at specified addresses based on the lengths in linesLength.
+    
+    Parameters:
+        romData (bytes): The complete ROM data.
+        addressesList (list): A list of addresses to read the texts from.
+        endOffset (set): The final offset after the last address.
+        charTable (dict): A dictionary mapping byte values to characters or sequences.
+    
+    Returns:
+        tuple: Containing:
+            - texts (list): Extracted script text.
+            - totalBytesRead (int): Total text block size.
+            - linesLength (list): Length of each line in bytes.
+    """
+    texts = []  
+    linesLength = []
+    total = 0
+
+    # Add final offset to the addressesList
+    addressesList.append(int(endOffset.pop()))
+
+    # Calculate lines lenght of each segment is the difference between consecutive addresses
+    for i in range(len(addressesList) - 1):
+        length = int(addressesList[i + 1]) - int(addressesList[i])
+        linesLength.append(length)
+
+    # Loop over each starting address in the list and use linesLength for determining byte ranges
+    for i in range(len(addressesList) - 1):
+        startAddr = addressesList[i]
+        length = linesLength[i]  # Get the length for this segment
+        endAddr = startAddr + length
+        
+        text = bytearray()
+        decodedValidCharacter = False
+        
+        # Read bytes from the starting address to the end address (using the specified length)
+        for addr in range(startAddr, endAddr):
+            byte = romData[addr]
+
+            # Map the byte using charTable to get the character
+            char = charTable.get(byte, None)  
+            if char:
+                # If single character
+                if len(char) == 1:
+                    text.append(ord(char))
+                    decodedValidCharacter = True
+                # If multiple characters (DTE/MTE)
+                else:  
+                    for c in char:
+                        text.append(ord(c))
+                    decodedValidCharacter = True
+            # If byte is not in charTable, print in format ~hex~
+            else:
+                hexValue = format(byte, '02X')
+                text.extend(f"~{hexValue}~".encode('UTF-8'))
+        
+        # Convert byte array to string
+        decodedText = text.decode('iso-8859-1', errors='replace')
+
+        # Append the decoded text to the list
+        texts.append(decodedText)
+        total += length
+
+    # Calculate total bytes read (this will be the sum of all lengths in linesLength)
+    totalBytesRead = total
+
+    return texts, totalBytesRead, linesLength
+
 def parseLineBreakers(string):
     """
     Parse a string of comma-separated hexadecimal values into a set of integers.
@@ -257,8 +328,11 @@ def parseLineBreakers(string):
     for byte in string.split(','):
         byte = byte.strip() 
         lineBreakers.add(int(byte, 16))
+
+    # If the lineBreaker are the final text offset
+    is_offset = any(value > 255 for value in lineBreakers)
 
-    return lineBreakers
+    return lineBreakers, is_offset
 
 def formatHexString(hexString):
     """

dist/HexString.exe

@@ -30,7 +30,7 @@ def readScriptFile(file):
 
     # Process text (excluding comments)
         textData = [
-            line.rstrip() for line in f.readlines()
+            line.rstrip('\n') for line in f.readlines()
             if not (line.startswith(";") or line.startswith("@") or line.startswith("|"))
         ]
     return textData, hexData[0], hexData[1], hexData[2], lineBreakers
@@ -282,7 +282,7 @@ def calculatePointer4Bytes(listCumulativeLength, firstPointer, headerSize=None):
         pointersData.append(ptr & 0xFF)             # Least significant byte
     return pointersData
 
-def writeROM(romFile, startOffset, data):
+def writePointers(romFile, startOffset, data):
     """
     Writes data to the ROM at the specified offset.
     
@@ -294,3 +294,28 @@ def writeROM(romFile, startOffset, data):
     with open(romFile, "r+b") as f: 
         f.seek(startOffset)
         f.write(data)
+        
+def writeText(romFile, startOffset, maxSize, data):
+    """
+    Writes data to the ROM at the specified offset.
+    
+    Parameters:
+        romFile (str): The path to the ROM file.
+        startOffset (int): The offset in the ROM file where data should be written.
+        data (bytes or bytearray): The data to write to the ROM.
+    """
+    # Check that the size of the data does not exceed the maximum allowed
+    if len(data) > int(maxSize):
+        excess = len(data) - int(maxSize)
+        return False
+    
+    # Check free space
+    freeSpace = int(maxSize) - len(data)
+
+    # Fill free space
+    filledData = data + b'\xFF' * freeSpace
+        
+    with open(romFile, "r+b") as f: 
+        f.seek(startOffset)
+        f.write(filledData)
+        return True

encoder.py

@@ -1,6 +1,6 @@
 ## HexString
 ## Source code by koda
-## release 03/12/2024 --version 1.1
+## release 03/01/2025 --version 1.2 (no space)
 
 import sys
 import os
@@ -51,7 +51,7 @@ def main():
         except ValueError:
             print("Error: Incorrect hex value.")
             sys.exit(1)
-        lineBreaker = sys.argv[7]                                   # Line breaker input (comma-separated)
+        lineBreaker = sys.argv[7]                                   # Line breaker input
         outFile = sys.argv[8]                                       # Output file for the extracted text
         tblFile = sys.argv[9]                                       # Tbl file argument
 
@@ -64,7 +64,7 @@ def main():
 
         # Parse line breakers.
         try:
-            parseLineBreakers = de.parseLineBreakers(lineBreaker)
+            parseLineBreakers, isOffset = de.parseLineBreakers(lineBreaker)
         except ValueError:
             print("Error: Incorrect hex value.")
             sys.exit(1)
@@ -86,7 +86,10 @@ def main():
 
         # Extract the texts
         try:
-            texts, totalBytesRead, linesLenght = de.extractTexts(romData, lineStartAddress, parseLineBreakers, charTable)
+            if not isOffset:
+                texts, totalBytesRead, linesLenght = de.extractTexts(romData, lineStartAddress, parseLineBreakers, charTable)
+            else:
+                texts, totalBytesRead, linesLenght = de.extractTextsNoLineBreakers(romData, lineStartAddress, parseLineBreakers, charTable)
         except IndexError:
             print(f"Error: Start address is bigger than the ROM size.")
             sys.exit(1)
@@ -166,33 +169,29 @@ def main():
 
         # Format pointers
         encodedPointers = pointersFormat(pointersList, textStartAddress, headerSize)
-
-        # Check that the size of the data does not exceed the maximum allowed
-        if len(encodedText) > int(textSize):
-            excess = len(encodedText) - int(textSize)
-            sys.stdout.write("Error: The number of bytes read exceeds the maximum block limit.\n")
-            sys.stdout.write(f"Remove {excess} bytes from {scriptFile} file.\n") 
-            sys.exit(1)
-
-        # Check free bytes
-        freeBytes = int(textSize) - len(encodedText)
-            
+        
         # Write the text to the ROM
         try:
-            en.writeROM(romFile, textStartAddress, encodedText)
+            if en.writeText(romFile, textStartAddress, textSize, encodedText):
+                # Write the pointers to the ROM
+                en.writePointers(romFile, pointersStartAddress, encodedPointers)
+                freeSpace = int(textSize) - len(encodedText)
+                print(f"Text written at offset {hex(textStartAddress)}.")
+                print(f"Pointers table written at offset {hex(pointersStartAddress)} with {len(pointersList)} pointers.")
+                print(f"Free space: {freeSpace} bytes.")
+                print(f"Data written to {romFile}")
+                print("Encoding complete.\n")
+                sys.exit(1)
+
+            else:
+                excess = len(encodedText) - int(textSize)
+                sys.stdout.write("Error: The number of bytes read exceeds the maximum block limit.\n")
+                sys.stdout.write(f"Remove {excess} bytes from {scriptFile} file.\n") 
+                sys.exit(1)
+                
         except FileNotFoundError:
             print(f"Error: File {romFile} not found in directory.")
             sys.exit(1)
-            
-        # Write the pointers to the ROM
-        en.writeROM(romFile, pointersStartAddress, encodedPointers)
-
-        print(f"Text written at offset {hex(textStartAddress)}.")
-        print(f"Pointers table written at offset {hex(pointersStartAddress)} with {len(pointersList)} pointers.")
-        print(f"Free space: {freeBytes} bytes.")
-        print(f"Data written to {romFile}")
-        print("Encoding complete.\n")
-        sys.exit(1)
 
     elif sys.argv[1] == '-h':
         print("\nUsage: HexString [-d|e] [input_file output_file]")
@@ -209,14 +208,11 @@ def main():
         sys.exit(1)
 
     elif sys.argv[1] == '-v':
-        sys.stdout.write("\nHexSring created by koda, version 1.1.0")
+        sys.stdout.write("\nHexSring created by koda, version 1.2")
         sys.exit(1)
 
     else:
-        sys.stdout.write("Usage: -d <pointersFormat> <romFile> <PointersStartAddress> <PointerTableSize> <HeaderSize> <LineBreaker> <outFile> <tblFile>\n")
-        sys.stdout.write("       -e <pointersFormat> <TextFile> <TextStartAddress> <TextSize> <PointersStartAddress> <HeaderSize> <romFile> <tblFile>\n")
-        sys.stdout.write("       -h show help.\n")
-        sys.stdout.write("       -v show version.\n")
+        showHelp()
         sys.exit(1)
 
 if __name__ == '__main__':