Merge pull request #36 from cormacj/bugfixing

bump to v0.90. Fix defining words. Bugfix byte processing

Author: cormacj

CHANGELOG.md

@@ -3,4 +3,6 @@
 2025-03-21: Bump to v0.80 - Add support for external labels, such as BIOS calls. Improved code detection methods.
 2025-06-13: Bump to v0.85 - Add the ability to define user-defined labels to the labels file. Increased error handling, more informational messages.
 2025-06-18: Bump to v0.87 - Corrected issues with string detection where strings weren't being properly decoded.
-2025-06-20: Bump to v0.89 - Bugfix for dropped `JP (IY)` instructions. Made JR decoding match the style of other jumps.
+2025-06-20: Bump to v0.89 - Bugfix for dropped `JP (IY)` instructions.
+            Made JR decoding match the style of other jumps.
+            Added template support for defining words

README.md

@@ -236,14 +236,12 @@ A template file is a standard text file. The format for the file is as follows:
     `start address, end address, data type, label`
 
   data types can be one of these:<br>
-    b = byte *<br>
+    b = byte <br>
     w = word<br>
     s = string<br>
     c = code<br>
     p = pointer<br>
 
-        * = still to be implimented
-
   You can refer to a pointer by enclosing the address in (). When the disassembler sees this, it looks at the word at the pointer location and uses that value instead.
 
   For example, in Amstrad ROMs 0xc004 is a pointer to the command names table. If a ROM has a value of `0xc123` at location `0xc004`, a template line should look like this:

z80-disassembler.py

@@ -90,7 +90,7 @@ class Pointer(NamedTuple):
 str_sizes = {}
 style = "asm"
 hexstyle = "0x"
-myversion = "0.89"
+myversion = "0.90"
 
 
 #--- Debugging functions ---
@@ -434,16 +434,16 @@ def process_template(filename):
                             #         print(loop)
                             #     mark_handled(addr,1,"D")
                             case "b":
-                                mark_handled(addr,2,"Db")
+                                mark_handled(addr,1,"Db")
                             case "w":
-                                mark_handled(addr,2,"Dw")
+                                mark_handled(addr,1,"Dw")
                             case "c":
                                 # print("Code:",hex(begin),hex(end))
                                 for loop in range(begin,end):
                                     mark_handled(loop,1,"C")
                                 mark_handled(addr,3,"C")
                             case "p":
-                                mark_handled(addr,2,"Dw")
+                                mark_handled(addr,2,"Dp")
                                 code_loc=begin #Get the address where the pointer is pointing to
                                 # mark_handled(code_loc,2,"Dw")
                             case "s":
@@ -779,6 +779,8 @@ def type_lookup(datatype):
             return "data"
         case "Dw":
             return "data"
+        case "Dp":
+            return "data"
         case "C":
             return "code"
 
@@ -1269,7 +1271,7 @@ def findstring(memstart, memend):
                 )
             )
             program_counter += 1
-    elif identified(program_counter) == "Dw":
+    elif identified(program_counter) == "Dp":
         if is_in_code(program_counter):
             tmp = get_from_code(program_counter,0) #code[loc][0]
             out_tmp = (
@@ -1608,14 +1610,40 @@ def findstring(memstart, memend):
             # debug("PC Bump")
             program_counter += 1 #FIXME - tripping PC too much?
     elif identified(program_counter) == "Dw":
+        if is_in_code(program_counter):
+            tmpl = get_from_code(program_counter,0) #Low byte
+            tmph = get_from_code(program_counter+1,0) # High byte
+            tmp = (tmph*0x100)+tmpl #make it a word
+            out_tmp=""
+            # print(f'\n\n{hex(tmp)}\n')
+            # out_tmp = (
+            #     f'"{chr(tmpl)}"'
+            #     if 31 < tmpl < 127
+            #     else (
+            #         f"('{chr(tmpl - 0x80)}') + {hexstyle}80" if 31 < (tmpl - 0x80) < 127 else hex(tmpl)
+            #     )
+            # )
+            # out_tmp = out_tmp+" "+(
+            #     f'"{chr(tmph)}"'
+            #     if 31 < tmph < 127
+            #     else (
+            #         f"('{chr(tmph - 0x80)}') + {hexstyle}80" if 31 < (tmph - 0x80) < 127 else hex(tmph)
+            #     )
+            # )
+            if commentlevel==0:
+                out_tmp="; "+out_tmp
+
+            code_output(program_counter, f"DEFB {hexstyle}{tmp:x}", list_address, f'{out_tmp}')
+            program_counter += 2
+    elif identified(program_counter) == "Dp":
         # dump_code_array("---->",program_counter)
 
         # debug("D2 - 2")
         if is_in_code(program_counter):
             # debug("D - 3")
             tmpl = get_from_code(program_counter,0) #Low byte
             tmph = get_from_code(program_counter+1,0) #High byte
-            tmp=((tmph*256)+tmpl) #make it a word
+            tmp=((tmph*0x100)+tmpl) #make it a word
             if (tmp in labels) or (tmp in template_labels):
                 if (tmp in template_labels):
                     labelname=template_labels[tmp]
@@ -1657,7 +1685,6 @@ def findstring(memstart, memend):
             # debug("C - 1a")
             # debug("Processing relative jump")
             jump_addr = handle_jump(b, program_counter)
-            # print(hex(jump_addr),lookup_label(jump_addr))
             djnz_addr=lookup_label(jump_addr)
             this_opcode = b.op.name
             if len(z80.disasm(b).split(",")) > 1:  # conditional jumps and calls
@@ -1675,6 +1702,9 @@ def findstring(memstart, memend):
                     # where $ is the current location, so this code adds the operator
                     # if its positive
                     tmp=f"{this_opcode} ${oper}{handle_jump(b,program_counter,True)} "
+                    # if program_counter>0xc840 and program_counter<0xc862:
+                    #     print(f'{hex(program_counter)}: {hex(jump_addr)} -> {lookup_label(jump_addr)}, opcode={z80.disasm(b)} --> {tmp}  {handle_jump(b,program_counter,True)} {hex(handle_jump(b,program_counter))} lookup: {lookup_label(jump_addr)} or {lookup_label(handle_jump(b,program_counter))}')
+
                 else:
                     if "," in this_opcode: # Fixup for JR nz, ADDR so this removes the space if it's a conditional JR
                         tmp = f"{this_opcode}" + lookup_label(jump_addr)