WIP. Python3 changes.

Author: deadsy

mem.py

@@ -130,7 +130,7 @@ def cmd_rd(self, ui, args, n):
       return
     adr = util.align(adr, n)
     ui.put('[0x%08x] = ' % adr)
-    ui.put('0x%%0%dx\n' % (n/4) % self.cpu.rd(adr, n))
+    ui.put('0x%%0%dx\n' % (n >> 2) % self.cpu.rd(adr, n))
 
   def cmd_rd8(self, ui, args):
     """read 8 bits"""
@@ -160,7 +160,7 @@ def cmd_wr(self, ui, args, n):
     val = util.mask_val(val, n)
     self.cpu.wr(adr, val, n)
     ui.put('[0x%08x] = ' % adr)
-    ui.put('0x%%0%dx\n' % (n/4) % val)
+    ui.put('0x%%0%dx\n' % (n >> 2) % val)
 
   def cmd_wr8(self, ui, args):
     """write 8 bits"""
@@ -241,7 +241,7 @@ def __display(self, ui, args, width):
     else:
       assert False, 'bad width'
     # read and print the data
-    for i in range(n/16):
+    for i in range(n >> 4):
       # read 4, 32-bit words (16 bytes per line)
       io = iobuf.data_buffer(32)
       self.cpu.rdmem(adr, 4, io)
@@ -309,8 +309,8 @@ def cmd_pic(self, ui, args):
     # bytes per row
     bpr = cols * bps
     # work out the none padding
-    nwords = n / 4
-    nwords_displayed = (((cols * rows * bps) + 3) & ~3) / 4
+    nwords = n >> 2
+    nwords_displayed = (((cols * rows * bps) + 3) & ~3) >> 2
     none_pad = [None,] * ((nwords_displayed - nwords) * 4)
     # read the memory
     if n > (16 << 10):
@@ -354,7 +354,7 @@ def cmd_md5(self, ui, args):
       ui.put('reading memory ...\n')
     data = iobuf.data_buffer(32)
     t_start = time.time()
-    self.cpu.rdmem(adr, n/4, data)
+    self.cpu.rdmem(adr, n >> 2, data)
     t_end = time.time()
     ui.put('%s\n' % data.md5('le'))
     ui.put('%.2f KiB/sec\n' % (float(n)/((t_end - t_start) * 1024.0)))
@@ -374,7 +374,7 @@ def cmd_test(self, width, ui, args):
     # round up n to an integral multiple of 4 bytes
     n = (n + 3) & ~3
     # convert to n 32/16/8-bit units
-    nx = n / (width / 8)
+    nx = int(n / (width >> 3))
     maxval = (1 << width) - 1
     # we will typically be testing ram, so halt the cpu.
     self.cpu.halt()

soc.py

@@ -29,7 +29,6 @@ def description_cleanup(s):
   """cleanup a description string"""
   if s is None:
     return None
-  s = util.rm_non_ascii(s)
   s = s.strip('."')
   # remove un-needed white space
   return ' '.join([x.strip() for x in s.split()])
@@ -299,7 +298,7 @@ def bind_cpu(self, cpu):
     self.cpu = cpu
 
   def adr(self, idx, size):
-    return self.parent.address + self.offset + (idx * (size / 8))
+    return self.parent.address + self.offset + (idx * (size >> 3))
 
   def rd(self, idx=0):
     return self.cpu.rd(self.adr(idx, self.size), self.size)
@@ -319,9 +318,7 @@ def clr_bit(self, val, idx=0):
   def field_list(self):
     """return an ordered fields list"""
     # build a list of fields in most significant bit order
-    f_list = self.fields.values()
-    f_list.sort(key=lambda x: x.msb, reverse=True)
-    return f_list
+    return sorted(self.fields.values(), key = lambda x : x.msb, reverse=True)
 
   def display(self, display_fields):
     """return display columns (name, adr, val, descr) for this register"""
@@ -400,9 +397,7 @@ def register_list(self):
     """return an ordered register list"""
     # build a list of registers in address offset order
     # tie break with the name to give a well-defined sort order
-    r_list = self.registers.values()
-    r_list.sort(key=lambda x: (x.offset << 16) + sum(bytearray(x.name)))
-    return r_list
+    return sorted(self.registers.values(), key = lambda x : (x.offset << 16) + sum(bytearray(x.name.encode('utf8'))))
 
   def display(self, register_name=None, fields=False):
     """return a display string for this peripheral"""
@@ -539,16 +534,12 @@ def peripheral_list(self):
     # build a list of peripherals in base address order
     # base addresses for peripherals are not always unique. e.g. nordic chips
     # so tie break with the name to give a well-defined sort order
-    p_list = self.peripherals.values()
-    p_list.sort(key=lambda x: (x.address << 16) + sum(bytearray(x.name)))
-    return p_list
+    return sorted(self.peripherals.values(), key = lambda x : (x.address << 16) + sum(bytearray(x.name.encode('utf8'))))
 
   def interrupt_list(self):
     """return an ordered interrupt list"""
     # sort by irq order
-    i_list = self.interrupts.values()
-    i_list.sort(key=lambda x: x.irq)
-    return i_list
+    return sorted(self.interrupts.values(), key = lambda x : x.irq)
 
   def cmd_map(self, ui, args):
     """display memory map"""

util.py

@@ -52,9 +52,8 @@ def wrong_argc(ui, args, valid):
   argc = len(args)
   if argc in valid:
     return False
-  else:
-    ui.put(bad_argc)
-    return True
+  ui.put(bad_argc)
+  return True
 
 # -----------------------------------------------------------------------------
 
@@ -85,9 +84,8 @@ def dict_arg(ui, arg, d):
   """argument to value through a dictionary - or None"""
   if arg in d:
     return d[arg]
-  else:
-    ui.put(inv_arg)
-    return None
+  ui.put(inv_arg)
+  return None
 
 # ----------------------------------------------------------------------------
 
@@ -195,8 +193,7 @@ def maskshift(field):
   """return a mask and shift defined by field"""
   if len(field) == 1:
     return (1 << field[0], field[0])
-  else:
-    return (((1 << (field[0] - field[1] + 1)) - 1) << field[1], field[1])
+  return (((1 << (field[0] - field[1] + 1)) - 1) << field[1], field[1])
 
 def bits(val, field):
   """return the bits (masked and shifted) from the value"""
@@ -246,7 +243,7 @@ def format_bit(x, c):
   """return a character to represent a bit state"""
   if x == 0:
     return '.'
-  elif x == 1:
+  if x == 1:
     return c
   return ' '
 
@@ -269,7 +266,7 @@ def rm_prefix(names, prefix_set):
   # remove the prefix
   if n:
     #print('removing prefix %s' % names[0][:n])
-    for i in range(len(names)):
+    for i, _ in enumerate(names):
       names[i] = names[i][n:]
 
 def rm_suffix(names, suffix_set):
@@ -289,29 +286,18 @@ def rm_suffix(names, suffix_set):
   # remove the suffix
   if n:
     #print('removing suffix %s' % names[0][-n:])
-    for i in range(len(names)):
+    for i, _ in enumerate(names):
       names[i] = names[i][:-n]
 
 # -----------------------------------------------------------------------------
 
-def rm_non_ascii(s):
-  """remove non-ascii characters from a string"""
-  for i in range(len(s)):
-    try:
-      s[i].encode('ascii')
-    except:
-      s = s[i].replace(' ')
-  return s
-
-# -----------------------------------------------------------------------------
-
 def display_cols(clist, csize=None):
   """
     return a string for a list of columns
     each element in clist is [col0_str, col1_str, col2_str, ...]
     csize is a list of column width minimums
   """
-  if len(clist) == 0:
+  if not clist:
     return ''
   # how many columns?
   ncols = len(clist[0])