scripts: Simplified dbgtag.py, tweaked -x/--hex decoding

This drops the option to read tags from a disk file. I don't think I've
ever used this, and it requires quite a bit of circuitry to implement.

Also dropped -s/--string, because most tags can't be represented as
strings?

And tweaked -x/--hex flags to correctly parse spaces in arguments, so
now these are equivalent:

- ./scripts/dbgtag.py -x 00 03 00 08
- ./scripts/dbgtag.py -x "00 03 00 08"

scripts/crc32c.py

@@ -33,7 +33,8 @@ def crc32c(data, crc=0):
 def main(paths, **args):
     # interpret as sequence of hex bytes
     if args.get('hex'):
-        print('%08x' % crc32c(bytes(int(path, 16) for path in paths)))
+        bytes_ = [b for path in paths for b in path.split()]
+        print('%08x' % crc32c(bytes(int(b, 16) for b in bytes_)))
 
     # interpret as strings
     elif args.get('string'):

scripts/dbgflags.py

@@ -303,7 +303,7 @@ if __name__ == "__main__":
     import argparse
     import sys
     parser = argparse.ArgumentParser(
-            description="Decode littlefs error codes.",
+            description="Decode littlefs flags.",
             allow_abbrev=False)
     class AppendFlags(argparse.Action):
         def __call__(self, parser, namespace, value, option):

scripts/dbgtag.py

@@ -53,66 +53,6 @@ TAG_ECKSUM      = 0x3200    ## 0x3200  v-11 --1- ---- ----
 TAG_GCKSUMDELTA = 0x3300    ## 0x3300  v-11 --11 ---- ----
 
 
-# some ways of block geometry representations
-# 512      -> 512
-# 512x16   -> (512, 16)
-# 0x200x10 -> (512, 16)
-def bdgeom(s):
-    s = s.strip()
-    b = 10
-    if s.startswith('0x') or s.startswith('0X'):
-        s = s[2:]
-        b = 16
-    elif s.startswith('0o') or s.startswith('0O'):
-        s = s[2:]
-        b = 8
-    elif s.startswith('0b') or s.startswith('0B'):
-        s = s[2:]
-        b = 2
-
-    if 'x' in s:
-        s, s_ = s.split('x', 1)
-        return (int(s, b), int(s_, b))
-    else:
-        return int(s, b)
-
-# parse some rbyd addr encodings
-# 0xa       -> (0xa,)
-# 0xa.c     -> ((0xa, 0xc),)
-# 0x{a,b}   -> (0xa, 0xb)
-# 0x{a,b}.c -> ((0xa, 0xc), (0xb, 0xc))
-def rbydaddr(s):
-    s = s.strip()
-    b = 10
-    if s.startswith('0x') or s.startswith('0X'):
-        s = s[2:]
-        b = 16
-    elif s.startswith('0o') or s.startswith('0O'):
-        s = s[2:]
-        b = 8
-    elif s.startswith('0b') or s.startswith('0B'):
-        s = s[2:]
-        b = 2
-
-    trunk = None
-    if '.' in s:
-        s, s_ = s.split('.', 1)
-        trunk = int(s_, b)
-
-    if s.startswith('{') and '}' in s:
-        ss = s[1:s.find('}')].split(',')
-    else:
-        ss = [s]
-
-    addr = []
-    for s in ss:
-        if trunk is not None:
-            addr.append((int(s, b), trunk))
-        else:
-            addr.append(int(s, b))
-
-    return tuple(addr)
-
 def fromleb128(data):
     word = 0
     for i, b in enumerate(data):
@@ -274,57 +214,14 @@ def main(tags, *,
     else:
         # interpret as a sequence of hex bytes
         if args.get('hex'):
-            dbg_tag(bytes(int(tag, 16) for tag in tags))
+            bytes_ = [b for tag in tags for b in tag.split()]
-
+            dbg_tag(bytes(int(b, 16) for b in bytes_))
-        # interpret as strings
-        elif args.get('string'):
-            for tag in tags:
-                dbg_tag(tag.encode('utf8'))
 
         # default to interpreting as ints
-        elif block_size is None and off is None:
+        else:
             for tag in tags:
                 dbg_tag(int(tag, 0))
 
-        # if either block_size or off provided interpret as a block device
-        else:
-            disk, *blocks = tags
-            blocks = [rbydaddr(block) for block in blocks]
-
-            # is bd geometry specified?
-            if isinstance(block_size, tuple):
-                block_size, block_count_ = block_size
-                if block_count is None:
-                    block_count = block_count_
-
-            # flatten block, default to block 0
-            if not blocks:
-                blocks = [(0,)]
-            blocks = [block for blocks_ in blocks for block in blocks_]
-
-            with open(disk, 'rb') as f:
-                # if block_size is omitted, assume the block device is one
-                # big block
-                if block_size is None:
-                    f.seek(0, os.SEEK_END)
-                    block_size = f.tell()
-
-                # blocks may also encode offsets
-                blocks, offs = (
-                        [block[0] if isinstance(block, tuple) else block
-                            for block in blocks],
-                        [off if off is not None
-                                else block[1] if isinstance(block, tuple)
-                                else None
-                            for block in blocks])
-
-                # read each tag
-                for block, off in zip(blocks, offs):
-                    f.seek((block * block_size) + (off or 0))
-                    # read maximum tag size
-                    data = f.read(2+5+5)
-                    dbg_tag(data)
-
 
 if __name__ == "__main__":
     import argparse
@@ -344,22 +241,6 @@ if __name__ == "__main__":
             '-x', '--hex',
             action='store_true',
             help="Interpret as a sequence of hex bytes.")
-    parser.add_argument(
-            '-s', '--string',
-            action='store_true',
-            help="Interpret as strings.")
-    parser.add_argument(
-            '-b', '--block-size',
-            type=bdgeom,
-            help="Block size/geometry in bytes.")
-    parser.add_argument(
-            '--block-count',
-            type=lambda x: int(x, 0),
-            help="Block count in blocks.")
-    parser.add_argument(
-            '--off',
-            type=lambda x: int(x, 0),
-            help="Use this offset.")
     sys.exit(main(**{k: v
             for k, v in vars(parser.parse_intermixed_args()).items()
             if v is not None}))

scripts/parity.py

@@ -33,9 +33,10 @@ def parity(x):
 def main(paths, **args):
     # interpret as sequence of hex bytes
     if args.get('hex'):
+        bytes_ = [b for path in paths for b in path.split()]
         print('%01x' % parity(ft.reduce(
                 op.xor,
-                bytes(int(path, 16) for path in paths),
+                bytes(int(b, 16) for b in bytes_),
                 0)))
 
     # interpret as strings