Updated the cli files.

Fixed an issue with io buffer sizing.

Author: deadsy

cli.py

@@ -13,12 +13,22 @@
 Notes:
 
 Menu Tuple Format:
-(name, descr, submenu) - submenu
-(name, descr, leaf) - leaf command with generic <cr> help
-(name, descr, leaf, help) - leaf command with specific help
+  (name, submenu, description) - submenu
+  (name, leaf) - leaf command with generic <cr> help
+  (name, leaf, help) - leaf command with specific argument help
 
 Help Format:
-(parm, descr)
+  (parm, descr)
+
+Leaf Functions:
+
+def leaf_function(ui, args):
+ .....
+
+ui: the ui object passed by the application to cli()
+args: the argument list from the command line
+
+The general help for a leaf function is the docstring for that function.
 """
 #-----------------------------------------------------------------------------
 
@@ -45,8 +55,6 @@
   ('<index>', 'recall history entry <index>'),
 )
 
-help_fmt = '  %-20s: %s\n'
-
 #-----------------------------------------------------------------------------
 
 def split_index(s):
@@ -111,16 +119,15 @@ def display_function_help(self, help_info):
     """display function help"""
     s = []
     for (parm, descr) in help_info:
-      if parm is None:
-        s.append(['', ''])
-      elif descr is None:
-        s.append([parm, ''])
-      else:
-        s.append([parm, ': %s' % descr])
-    self.ui.put('%s\n' % util.display_cols(s, [16, 0]))
+      p_str = (parm, '')[parm is None]
+      d_fmt = (': %s', '  %s')[parm is None]
+      d_str = (d_fmt % descr, '')[descr is None]
+      s.append(['  ', p_str, d_str])
+    self.ui.put('%s\n' % util.display_cols(s, [0, 16, 0]))
 
   def command_help(self, cmd, menu):
     """display help results for a command at a menu level"""
+    s = []
     for item in menu:
       name = item[0]
       if name.startswith(cmd):
@@ -130,7 +137,8 @@ def command_help(self, cmd, menu):
         else:
           # command: docstring is the help
           descr = item[1].__doc__
-        self.ui.put(help_fmt % (name, descr))
+        s.append(['  ', name, ': %s' % descr])
+    self.ui.put('%s\n' % util.display_cols(s, [0, 16, 0]))
 
   def function_help(self, item):
     """display help for a leaf function"""

iobuf.py

@@ -67,6 +67,14 @@ def wr32(self, data):
     self.emit16(data & 0xffff)
     self.emit16(data >> 16)
 
+  def has_rd(self, n):
+    """no read supported"""
+    return False
+
+  def has_wr(self, n):
+    """wr32 supported"""
+    return n == 32
+
 #-----------------------------------------------------------------------------
 
 class write_file(object):
@@ -101,6 +109,14 @@ def wr8(self, val):
     self.n += 1
     self.progress.update(self.n)
 
+  def has_rd(self, n):
+    """no read supported"""
+    return False
+
+  def has_wr(self, n):
+    """wr8/16/32 supported"""
+    return n == 32 or n == 16 or n == 8
+
 #-----------------------------------------------------------------------------
 
 class read_file(object):
@@ -153,6 +169,14 @@ def rd8(self):
     self.progress.update(self.n)
     return struct.unpack('B', val)[0]
 
+  def has_rd(self, n):
+    """rd8/16/32 supported"""
+    return n == 32 or n == 16 or n == 8
+
+  def has_wr(self, n):
+    """no write supported"""
+    return False
+
 #-----------------------------------------------------------------------------
 
 class verify_file(object):
@@ -190,6 +214,14 @@ def wr32(self, val):
     self.n += 4
     self.progress.update(self.n)
 
+  def has_rd(self, n):
+    """no read supported"""
+    return False
+
+  def has_wr(self, n):
+    """wr32 supported"""
+    return n == 32
+
 #-----------------------------------------------------------------------------
 
 class data_buffer(object):
@@ -250,6 +282,14 @@ def wr8(self, val):
     assert self.width == 8
     self.write(val)
 
+  def has_rd(self, n):
+    """rdN supported"""
+    return n == self.width
+
+  def has_wr(self, n):
+    """wrN supported"""
+    return n == self.width
+
   def convert8(self, mode):
     """convert the buffer to 8 bit values"""
     if self.width == 32:

jlink.py

@@ -1,7 +1,6 @@
 # ----------------------------------------------------------------------------
 
 import sys
-import time
 import os
 import ctypes
 import struct
@@ -23,9 +22,9 @@
 # map register names to jlink register numbers
 
 regmap = {
-  'r0':0,'r1':1,'r2':2,'r3':3,'r4':4,'r5':5,'r6':6,'r7':7,
-  'r8':8,'r9':9,'r10':10,'r11':11,'r12':12,'r13':13,'r14':14,'r15':15,
-  'lr':14,'pc':15,'psr':16,'msp':13,
+  'r0':0, 'r1':1, 'r2':2, 'r3':3, 'r4':4, 'r5':5, 'r6':6, 'r7':7,
+  'r8':8, 'r9':9, 'r10':10, 'r11':11, 'r12':12, 'r13':13, 'r14':14, 'r15':15,
+  'lr':14, 'pc':15, 'psr':16, 'msp':13,
   # psp
   # primask
   # faultmask
@@ -75,8 +74,7 @@ def locate_library(libname, paths=sys.path, loader=None):
     if os.path.exists(library):
       sys.stderr.write('using %r\n' % library)
       return loader.LoadLibrary(library), library
-  else:
-    raise IOError('%s not found' % libname)
+  raise IOError('%s not found' % libname)
 
 def get_jlink_dll():
   # what kind of system am I?
@@ -90,8 +88,7 @@ def get_jlink_dll():
     raise Exception(repr(platform.architecture()))
 
   # start with the script path
-  search_path = [os.path.join(os.path.dirname(
-      os.path.realpath(__file__)), libpath)]
+  search_path = [os.path.join(os.path.dirname(os.path.realpath(__file__)), libpath)]
   search_path += sys.path[:]  # copy sys.path list
 
   # if environment variable is set, insert this path first
@@ -106,18 +103,16 @@ def get_jlink_dll():
   if sys.platform == 'win32':
     jlink, backend_info = locate_library('jlinkarm.dll', search_path)
   elif sys.platform == 'linux2':
-    jlink, backend_info = locate_library(
-        'libjlinkarm.so.5', search_path, ctypes.cdll)
+    jlink, backend_info = locate_library('libjlinkarm.so.5', search_path, ctypes.cdll)
   elif sys.platform == 'darwin':
-    jlink, backend_info = locate_library(
-        'libjlinkarm.so.5.dylib', search_path, ctypes.cdll)
+    jlink, backend_info = locate_library('libjlinkarm.so.5.dylib', search_path, ctypes.cdll)
   return jlink, backend_info
 
 # ----------------------------------------------------------------------------
 
 class JLink(object):
 
-  def __init__(self, idx = 0):
+  def __init__(self, idx=0):
     self.usb_idx = idx
     # load the library
     self.jl, self.jlink_lib_name = get_jlink_dll()
@@ -291,7 +286,7 @@ def wrreg(self, reg, val):
     # void JLINKARM_WriteReg(int reg, uint32_t val);
     fn = self.jl.JLINKARM_WriteReg
     fn.restype = None
-    fn.argtypes = [c_int,c_uint32]
+    fn.argtypes = [c_int, c_uint32]
     fn(c_int(reg), c_uint32(val))
 
   def cp15_is_present(self):
@@ -305,7 +300,7 @@ def rd_cp15(self, crn, op1, crm, op2):
     # int JLINKARM_CP15_ReadEx(uint32_t crn, uint32_t crm, uint32_t op1, uint32_t op2, uint32_t *val)
     fn = self.jl.JLINKARM_CP15_ReadEx
     fn.restype = c_int
-    fn.argtypes = [c_uint32,c_uint32,c_uint32,c_uint32,c_void_p]
+    fn.argtypes = [c_uint32, c_uint32, c_uint32, c_uint32, c_void_p]
     val = c_uint32()
     rc = fn(c_uint32(crn), c_uint32(crm), c_uint32(op1), c_uint32(op2), ctypes.byref(val))
     assert rc == 0, 'JLINKARM_CP15_ReadEx returned %d' % rc
@@ -315,7 +310,7 @@ def wr_cp15(self, crn, op1, crm, op2, val):
     # int JLINKARM_CP15_WriteEx(uint32_t crn, uint32_t crm, uint32_t op1, uint32_t op2, uint32_t val)
     fn = self.jl.JLINKARM_CP15_WriteEx
     fn.restype = c_int
-    fn.argtypes = [c_uint32,c_uint32,c_uint32,c_uint32,c_uint32]
+    fn.argtypes = [c_uint32, c_uint32, c_uint32, c_uint32, c_uint32]
     rc = fn(c_uint32(crn), c_uint32(crm), c_uint32(op1), c_uint32(op2), c_uint32(val))
     assert rc == 0, 'JLINKARM_CP15_WriteEx returned %d' % rc
 
@@ -428,7 +423,7 @@ def __str__(self):
 class dbgio(object):
   """JLink implementation of dbgio cpu interface"""
 
-  def __init__(self, idx = 0):
+  def __init__(self, idx=0):
     """no actual operations, record the selected usb device"""
     self.usb_idx = idx
     self.menu = (
@@ -446,7 +441,7 @@ def connect(self, cpu_name, itf):
     # setup the jlink interface
     self.jlink.exec_command('device=%s' % cpu_names[cpu_name])
     self.jlink.set_speed(4000)
-    itf = {'swd':_JLINKARM_TIF_SWD,'jtag':_JLINKARM_TIF_JTAG}[itf]
+    itf = {'swd':_JLINKARM_TIF_SWD, 'jtag':_JLINKARM_TIF_JTAG}[itf]
     self.jlink.tif_select(itf)
     self.jlink.jlink_connect()
 
@@ -517,11 +512,11 @@ def rdmem8(self, adr, n, io):
 
   def rdmem(self, adr, n, io):
     """read a buffer from memory starting at adr"""
-    if io.width == 32:
+    if io.has_wr(32):
       self.rdmem32(adr, n, io)
-    elif io.width == 16:
+    elif io.has_wr(16):
       self.rdmem16(adr, n, io)
-    elif io.width == 8:
+    elif io.has_wr(8):
       self.rdmem8(adr, n, io)
     else:
       assert False, 'bad buffer width'
@@ -540,11 +535,11 @@ def wrmem8(self, adr, n, io):
 
   def wrmem(self, adr, n, io):
     """write a buffer to memory starting at adr"""
-    if io.width == 32:
+    if io.has_rd(32):
       self.wrmem32(adr, n, io)
-    elif io.width == 16:
+    elif io.has_rd(16):
       self.wrmem16(adr, n, io)
-    elif io.width == 8:
+    elif io.has_rd(8):
       self.wrmem8(adr, n, io)
     else:
       assert False, 'bad buffer width'

linenoise.py

@@ -64,7 +64,7 @@
 
 def _getc(fd, timeout=-1):
   """
-    read a single character from a file (with timeout)
+    read a single character string from a file (with timeout)
     timeout = 0 : return immediately
     timeout < 0 : wait for the character (block)
     timeout > 0 : wait for timeout seconds
@@ -78,7 +78,10 @@ def _getc(fd, timeout=-1):
   c = os.read(fd, 1)
   if c == '':
     return _KEY_NULL
-  return c
+  return c.decode('utf8')
+
+def _puts(fd, s):
+  return os.write(fd, s.encode('utf8'))
 
 def would_block(fd, timeout):
   """if fd is not readable within timeout seconds - return True"""
@@ -93,7 +96,7 @@ def would_block(fd, timeout):
 def get_cursor_position(ifd, ofd):
   """Get the horizontal cursor position"""
   # query the cursor location
-  if os.write(ofd, '\x1b[6n') != 4:
+  if _puts(ofd, '\x1b[6n') != 4:
     return -1
   # read the response: ESC [ rows ; cols R
   # rows/cols are decimal number strings
@@ -131,14 +134,14 @@ def get_columns(ifd, ofd):
     if start < 0:
       return _DEFAULT_COLS
     # Go to right margin and get position
-    if os.write(ofd, '\x1b[999C') != 6:
+    if _puts(ofd, '\x1b[999C') != 6:
       return _DEFAULT_COLS
     cols = get_cursor_position(ifd, ofd)
     if cols < 0:
       return _DEFAULT_COLS
     # restore the position
     if cols > start:
-      os.write(ofd, '\x1b[%dD' % (cols - start))
+      _puts(ofd, '\x1b[%dD' % (cols - start))
   return cols
 
 # -----------------------------------------------------------------------------
@@ -201,7 +204,7 @@ def refresh_show_hints(self):
     if bold and color < 0:
       color = 37
     if color >= 0 or bold:
-      seq.append('\033[%d;%d;49m' % ((0,1)[bold], color))
+      seq.append('\033[%d;%d;49m' % ((0, 1)[bold], color))
     seq.append(hint[:hlen])
     if color >= 0 or bold:
       seq.append('\033[0m')
@@ -234,7 +237,7 @@ def refresh_singleline(self):
     # Move cursor to original position
     seq.append('\r\x1b[%dC' % (plen + pos))
     # write it out
-    os.write(self.ofd, ''.join(seq))
+    _puts(self.ofd, ''.join(seq))
 
   def refresh_multiline(self):
     """multiline refresh"""
@@ -253,7 +256,7 @@ def refresh_multiline(self):
       logging.debug('go down %d' % (old_rows - rpos))
       seq.append('\x1b[%dB' % (old_rows - rpos))
     # Now for every row clear it, go up.
-    for j in xrange(old_rows-1):
+    for j in range(int(old_rows-1)):
       logging.debug('clear+up')
       seq.append('\r\x1b[0K\x1b[1A')
     # Clear the top line.
@@ -290,7 +293,7 @@ def refresh_multiline(self):
     logging.debug('\n')
     self.oldpos = self.pos
     # write it out
-    os.write(self.ofd, ''.join(seq))
+    _puts(self.ofd, ''.join(seq))
 
   def refresh_line(self):
     """refresh the edit line"""
@@ -397,7 +400,7 @@ def complete_line(self):
       idx = 0
       while not stop:
         if idx < len(lc):
-          # show the completion
+          # save the line buffer
           saved_buf = self.buf
           saved_pos = self.pos
           # show the completion

pycs

@@ -159,6 +159,9 @@ class user_interface(object):
   def put(self, s):
     sys.stdout.write(s)
 
+  def flush(self):
+    sys.stdout.flush()
+
   def poll(self):
     # poll the input during an operation
     # use a short timeout so we don't peg the cpu