Started work on compiler.

gcdcompile.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Parses a recipe file and builds a GCD file from it.
+"""
+
+from grmn import Gcd
+import sys
+
+if len(sys.argv) < 3:
+    print("Syntax: {} RCPFILE GCDFILE".format(sys.argv[0]))
+    sys.exit(1)
+
+RECIPE = sys.argv[1]
+OUTFILE = sys.argv[2]
+
+print("Opening recipe {}".format(RECIPE))
+gcd = Gcd.from_recipe(RECIPE)
+gcd.print_struct()
+#print("Dumping to {}".format(OUTFILE))
+#gcd.write_to_file(OUTFILE)

gcddump.py

@@ -9,13 +9,13 @@ from grmn import Gcd
 import sys
 
 if len(sys.argv) < 3:
-    print("Syntax: {} GCDFILE DUMPFILE (extension .rcp will be added)".format(sys.argv[0]))
+    print("Syntax: {} GCDFILE OUTPUTBASENAME (extension .rcp will be added)".format(sys.argv[0]))
     sys.exit(1)
 
 FILE = sys.argv[1]
-OUTFILE = sys.argv[2]
+OUTBASENAME = sys.argv[2]
 
 print("Opening {}".format(FILE))
 gcd = Gcd(FILE)
-print("Dumping to {}.rcp".format(OUTFILE))
-gcd.dump(OUTFILE)
+print("Dumping to {}.rcp".format(OUTBASENAME))
+gcd.dump_to_files(OUTBASENAME)

grmn/gcd.py

@@ -3,6 +3,8 @@
 
 from .chksum import ChkSum
 from .tlv import TLV, TLV6, TLV7
+from struct import unpack
+import configparser
 
 GCD_SIG = b"G\x41RM\x49Nd\00"
 DEFAULT_COPYRIGHT = b"Copyright 1996-2017 by G\x61rm\x69n Ltd. or its subsidiaries."
@@ -36,7 +38,8 @@ class Gcd:
             while True:
                 cur_offset = f.tell()
                 header = f.read(4)
-                tlv = TLV.factory(header, offset=cur_offset)
+                (type_id, length) = unpack("<HH", header)
+                tlv = TLV.factory(type_id, length, offset=cur_offset)
                 self.add_tlv(tlv)
                 if tlv.type_id == 0xFFFF:
                     # End of file reached
@@ -72,7 +75,8 @@ class Gcd:
                 print("#{:03d}: {}".format(i, tlv))
             else:
                 tlv_count += 1
-                tlv_length += tlv.length
+                if tlv.length is not None:
+                    tlv_length += tlv.length
             last_tlv = tlv.type_id
 
     def validate(self, print_stats: bool=False):
@@ -112,7 +116,7 @@ class Gcd:
             f.write("# {}\n".format(comment))
         f.write("{} = {}\n".format(key, value))
 
-    def dump(self, output_basename: str):
+    def dump_to_files(self, output_basename: str):
         output_file = "{}.rcp".format(output_basename)
         ctr = 0
         last_filename = None
@@ -148,3 +152,27 @@ class Gcd:
                             self.write_dump_param(f, item[0], item[1], item[2])
                 ctr += 1
             f.close()
+
+    @staticmethod
+    def from_recipe(recipe_file: str):
+        gcd = Gcd()
+        rcp = configparser.ConfigParser()
+        rcp.read(recipe_file)
+        if rcp["GCD_DUMP"]["dump_by"] != "grmn-gcd":
+            raise ParseException("Recipe file invalid.")
+        if rcp["GCD_DUMP"]["dump_ver"] != "1":
+            raise ParseException("Recipe file wrong version.")
+        for s in rcp.sections():
+            if s == "GCD_DUMP":
+                continue
+            print("Parsing {}".format(s))
+            if "from_file" in rcp[s]:
+                # BINARY! Must create type 0006, 0007 and actual binary blocks
+                print("Binary block")
+            else:
+                params = []
+                for k in rcp[s]:
+                    params.append((k, rcp[s][k]))
+                tlv = TLV.create_from_dump(params)
+                gcd.struct.append(tlv)
+        return gcd

grmn/tlv.py

@@ -33,8 +33,7 @@ class TLV:
             self.value = bytes(value)
 
     @staticmethod
-    def factory(header: bytes, offset: int = None):
-        (type_id, length) = unpack("<HH", header)
+    def factory(type_id: int, length: int = None, offset: int = None):
         if type_id == 0x0001:
             new_tlv = TLV1(type_id, length)
         elif type_id == 0x0002:
@@ -57,7 +56,13 @@ class TLV:
         plural = ""
         if self.length != 1:
             plural = "s"
-        return "TLV Type {:04x} at 0x{:x}, {:d} Byte{} - {}".format(self.type_id, self.offset, self.length, plural, self.comment)
+        offset = ""
+        if self.offset:
+            offset = " at 0x{:x}".format(self.offset)
+        lenstr = ""
+        if self.length:
+            lenstr = ", {:d} Byte{}".format(self.length, plural)
+        return "TLV Type {:04x}{}{} - {}".format(self.type_id, offset, lenstr, self.comment)
 
     def set_value(self, new_value: bytes):
         self.value = new_value
@@ -95,10 +100,19 @@ class TLV:
             data.append(("value", hexstr, None))
         return data
 
+    def load_dump(self, values):
+        pass
+
     @staticmethod
     def create_from_dump(values):
         """Use data exported with dump() to recreate object."""
-        pass
+        tlv = None
+        for (k, v) in values:
+            if k == "type":
+                type_id = int(v, 0)
+        tlv = TLV.factory(type_id)
+        tlv.load_dump(values)
+        return tlv
 
 class TLV1(TLV):
     def dump(self):
@@ -106,6 +120,11 @@ class TLV1(TLV):
         data.append(("type", "0x{:04x}".format(self.type_id), self.comment))
         return data
 
+    def load_dump(self, values):
+        for (k, v) in values:
+            if k == "value":
+                self.value = int(v, 0)
+
 class TLV2(TLV):
     def dump(self):
         data = []