WebSVN – freemyipod – Diff – /emcore/trunk/tools/emcore.py

 from functools import wraps
 import libemcore
 import libemcoredata
-from misc import Error, Logger, getfuncdoc, gethwname
+from misc import Error, ArgumentError, ArgumentTypeError, Logger, getfuncdoc, gethwname, to_bool, to_int
-class NotImplementedError(Error):
-    pass
-class ArgumentError(Error):
-    pass
-class ArgumentTypeError(Error):
-    def __init__(self, expected, seen=False):
-        self.expected = expected
-        self.seen = seen
-    def __str__(self):
-        if self.seen:
-            return "Expected %s but got %s" % (self.expected, self.seen)
-        else:
-            return "Expected %s, but saw something else" % self.expected
 def usage(errormsg=None, specific=False, docstring=True):
     """
         Prints the usage information.
                     raise
             except libemcore.usb.core.USBError:
                 self.logger.error("There is a problem with the USB connection.\n")
         else:
             usage("No such command!", docstring = False)
-    @staticmethod
-    def _bool(something):
-        """
-            Converts quite everything into bool.
-        """
-        if type(something) == bool:
-            return something
-        if something is None:
-            return False
-        elif type(something) == int or type(something) == long:
-            return bool(something)
-        elif type(something == str):
-            truelist = ['true', '1', 't', 'y', 'yes']
-            falselist = ['false', '0', 'f', 'n', 'no']
-            if something.lower() in truelist:
-                return True
-            elif something.lower() in falselist:
-                return False
-        raise ArgumentTypeError("bool", "'%s'" % something)
-    @staticmethod
-    def _hexint(something):
-        """
-            Converts quite everything to a hexadecimal represented integer.
-            This works for default arguments too, because it returns
-            None when it found that it got a NoneType object.
-        """
-        if type(something) == int or type(something) == long:
-            return something
-        elif type(something) == str:
-            try:
-                return int(something, 16)
-            except ValueError:
-                raise ArgumentTypeError("hexadecimal coded integer", "'%s'" % something)
-        elif something is None:
-            return None
-        else:
-            raise ArgumentTypeError("hexadecimal coded integer", "'%s'" % something)
     @command
     def help(self):
         """ Displays this help """
         usage(docstring = True)
         """
             Resets the device"
             If [force] is 1, the reset will be forced, otherwise it will be gracefully,
             which may take some time.
         """
-        force = self._bool(force)
+        force = to_bool(force)
         if force: self.logger.info("Resetting forcefully...\n")
         else: self.logger.info("Resetting...\n")
         self.emcore.reset(force)
     @command
         """
             Powers the device off
             If [force] is 1, the poweroff will be forced, otherwise it will be gracefully,
             which may take some time.
         """
-        force = self._bool(force)
+        force = to_bool(force)
         if force: self.logger.info("Powering off forcefully...\n")
         else: self.logger.info("Powering off...\n")
         self.emcore.poweroff(force)
     @command
         """
             Uploads a file to the device
             <filename>: The path to the file
             [addr]: The address to upload the file to. Allocates a chunk of memory if not given.
         """
-        addr = self._hexint(addr)
+        addr = to_int(addr)
         try:
             f = open(filename, 'rb')
         except IOError:
             raise ArgumentError("File not readable. Does it exist?")
         if addr is not None:
             Uploads a file to the device
             <offset>: the address to upload the file to
             <size>: the number of bytes to be read
             <filename>: the path to the file
         """
-        addr = self._hexint(addr)
+        addr = to_int(addr)
-        size = self._hexint(size)
+        size = to_int(size)
         try:
             f = open(filename, 'wb')
         except IOError:
             raise ArgumentError("Can not open file for write!")
         self.logger.info("Reading data from address 0x%X with the size 0x%X to '%s'..." %
         """
             Uploads a single integer to the device
             <addr>: the address to upload the integer to
             <integer>: the integer to upload
         """
-        addr = self._hexint(addr)
+        addr = to_int(addr)
-        integer = self._hexint(integer)
+        integer = to_int(integer)
         if integer > 0xFFFFFFFF:
             raise ArgumentError("Specified integer too long")
         data = struct.pack("I", integer)
         self.emcore.write(addr, data)
         self.logger.info("Integer '0x%X' written successfully to 0x%X\n" % (integer, addr))
     def downloadint(self, addr):
         """
             Downloads a single integer from the device and prints it to the console window
             <addr>: the address to download the integer from
         """
-        addr = self._hexint(addr)
+        addr = to_int(addr)
         data = self.emcore.read(addr, 4)
         integer = struct.unpack("I", data)[0]
         self.logger.info("Read '0x%X' from address 0x%X\n" % (integer, addr))
     @command
             <bus>: the bus index
             <slave>: the slave address
             <addr>: the start address on the I2C device
             <size>: the number of bytes to read
         """
-        bus = self._hexint(bus)
+        bus = to_int(bus)
-        slave = self._hexint(slave)
+        slave = to_int(slave)
-        addr = self._hexint(addr)
+        addr = to_int(addr)
-        size = self._hexint(size)
+        size = to_int(size)
         data = self.emcore.i2cread(bus, slave, addr, size)
         bytes = struct.unpack("%dB" % len(data), data)
         self.logger.info("Data read from I2C:\n")
         for index, byte in enumerate(bytes):
             self.logger.info("%02X: %02X\n" % (index, byte))
         """
             Writes data to an I2C device
             <bus>: the bus index
             <slave>: the slave address
             <addr>: the start address on the I2C device
-            <db1> ... <dbN>: the data in single bytes, encoded in hex,
+            <db1> ... <dbN>: the data in single bytes,
                 seperated by whitespaces, eg. 37 5A 4F EB
         """
-        bus = self._hexint(bus)
+        bus = to_int(bus)
-        slave = self._hexint(slave)
+        slave = to_int(slave)
-        addr = self._hexint(addr)
+        addr = to_int(addr)
         data = ""
         for arg in args:
-            data += chr(self._hexint(arg))
+            data += chr(to_int(arg))
         self.logger.info("Writing data to I2C...\n")
         self.emcore.i2cwrite(bus, slave, addr, data)
         self.logger.info("done\n")
     @command
     def readdevconsole(self, bitmask):
         """
             Reads data continuously from one or more of the device's consoles.
             <bitmask>: the bitmask of the consoles to read from.
         """
-        bitmask = self._hexint(bitmask)
+        bitmask = to_int(bitmask)
         while True:
             resp = self.emcore.cread()
             self.logger.write(resp.data)
             time.sleep(0.1 / resp.maxsize * (resp.maxsize - len(resp.data)))
     def writedevconsole(self, bitmask, *args):
         """
             Writes the string <db1> ... <dbN> to one or more of the device's consoles.
             <bitmask>: the bitmask of the consoles to write to
         """
-        bitmask = self._hexint(bitmask)
+        bitmask = to_int(bitmask)
         text = ""
         for word in args:
             text += word + " "
         text = text[:-1]
         self.logger.info("Writing '%s' to the device consoles identified with 0x%X\n" % (text, bitmask))
     def flushconsolebuffers(self, bitmask):
         """
             flushes one or more of the device consoles' buffers.
             <bitmask>: the bitmask of the consoles to be flushed
         """
-        bitmask = self._hexint(bitmask)
+        bitmask = to_int(bitmask)
         self.logger.info("Flushing consoles identified with the bitmask 0x%X\n" % bitmask)
         self.emcore.cflush(bitmask)
     @command
     def getprocinfo(self):
     @command
     def suspendthread(self, threadaddr):
         """
             Suspends the thread with the thread address <threadaddr>
         """
-        threadaddr = self._hexint(threadaddr)
+        threadaddr = to_int(threadaddr)
         self.logger.info("Suspending the thread with the threadaddr 0x%X\n" % threadaddr)
         self.emcore.suspendthread(threadaddr)
     @command
     def resumethread(self, threadaddr):
         """
             Resumes the thread with the thread address <threadaddr>
         """
-        threadaddr = self._hexint(threadaddr)
+        threadaddr = to_int(threadaddr)
         self.logger.info("Resuming the thread with the threadaddr 0x%X\n" % threadaddr)
         self.emcore.resumethread(threadaddr)
     @command
     def killthread(self, threadaddr):
         """
             Kills the thread with the thread address <threadaddr>
         """
-        threadaddr = self._hexint(threadaddr)
+        threadaddr = to_int(threadaddr)
         self.logger.info("Killing the thread with the threadaddr 0x%X\n" % threadaddr)
         self.emcore.killthread(threadaddr)
     @command
     def createthread(self, nameptr, entrypoint, stackptr, stacksize, threadtype, priority, state):
             <stacksize>: the size of the thread's stack
             <threadtype>: the thread type, vaild are: 0 => user thread, 1 => system thread
             <priority>: the priority of the thread, from 1 to 255
             <state>: the thread's initial state, valid are: 1 => ready, 0 => suspended
         """
-        nameptr = self._hexint(nameptr)
+        nameptr = to_int(nameptr)
-        entrypoint = self._hexint(entrypoint)
+        entrypoint = to_int(entrypoint)
-        stackptr = self._hexint(stackptr)
+        stackptr = to_int(stackptr)
-        stacksize = self._hexint(stacksize)
+        stacksize = to_int(stacksize)
-        priority = self._hexint(priority)
+        priority = to_int(priority)
         data = self.emcore.createthread(nameptr, entrypoint, stackptr, stacksize, threadtype, priority, state)
         name = self.emcore.readstring(nameptr)
         self.logger.info("Created a thread with the thread pointer 0x%X, the name \"%s\", the entrypoint at 0x%X," \
                          "the stack at 0x%X with a size of 0x%X and a priority of %d/255\n" %
                         (data.threadptr, name, entrypoint, stackptr, stacksize, priority))
     @command
     def execimage(self, addr):
         """
             Executes the emCORE application at <addr>.
         """
-        addr = self._hexint(addr)
+        addr = to_int(addr)
         self.logger.info("Starting emCORE app at 0x%X\n" % addr)
         self.emcore.execimage(addr)
     @command
     def flushcaches(self):
         """
             Reads <size> bytes from bootflash to memory.
             <addr_bootflsh>: the address in bootflash to read from
             <addr_mem>: the address in memory to copy the data to
         """
-        addr_flash = self._hexint(addr_flash)
+        addr_flash = to_int(addr_flash)
-        addr_mem = self._hexint(addr_mem)
+        addr_mem = to_int(addr_mem)
-        size = self._hexint(size)
+        size = to_int(size)
         self.logger.info("Dumping boot flash from 0x%X - 0x%X to 0x%X - 0x%X\n" %
                         (addr_flash, addr_flash + size, addr_mem, addr_mem + size))
         self.emcore.bootflashread(addr_mem, addr_flash, size)
     @command
             This may BRICK your device (unless it has a good recovery option)
             <addr_mem>: the address in memory to copy the data from
             <addr_bootflsh>: the address in bootflash to write to
             [force]: Use this flag to suppress the 5 seconds delay
         """
-        addr_flash = self._hexint(addr_flash)
+        addr_flash = to_int(addr_flash)
-        addr_mem = self._hexint(addr_mem)
+        addr_mem = to_int(addr_mem)
-        size = self._hexint(size)
+        size = to_int(size)
-        force = self._bool(force)
+        force = to_bool(force)
         self.logger.warn("Writing boot flash from the memory in 0x%X - 0x%X to 0x%X - 0x%X\n" %
                         (addr_mem, addr_mem + size, addr_flash, addr_flash + size))
         if force == False:
             self.logger.warn("If this was not what you intended press Ctrl-C NOW")
             for i in range(10):
     def runfirmware(self, targetaddr, filename):
         """
             Uploads the firmware in <filename>
             to an allocated buffer and executes it at <targetaddr>.
         """
-        targetaddr = self._hexint(targetaddr)
+        targetaddr = to_int(targetaddr)
         addr, size = self.uploadfile(filename)
         self.execfirmware(targetaddr, addr, size)
     @command
     def execfirmware(self, targetaddr, addr, size):
         """
             Moves the firmware at <addr> with <size> to <targetaddr> and executes it
         """
-        targetaddr = self._hexint(targetaddr)
+        targetaddr = to_int(targetaddr)
-        addr = self._hexint(addr)
+        addr = to_int(addr)
         size = self._hexint(size)
         self.logger.info("Running firmware at "+self._hex(targetaddr)+". Bye.\n")
         self.emcore.execfirmware(targetaddr, addr, size)
     @command
             Encrypts a buffer using a hardware key
             <addr>: the starting address of the buffer
             <size>: the size of the buffer
             <keyindex>: the index of the key in the crypto unit
         """
-        addr = self._hexint(addr)
+        addr = to_int(addr)
-        size = self._hexint(size)
+        size = to_int(size)
-        keyindex = self._hexint(keyindex)
+        keyindex = to_int(keyindex)
         self.emcore.aesencrypt(addr, size, keyindex)
     @command
     def aesdecrypt(self, addr, size, keyindex):
         """
             Decrypts a buffer using a hardware key
             <addr>: the starting address of the buffer
             <size>: the size of the buffer
             <keyindex>: the index of the key in the crypto unit
         """
-        addr = self._hexint(addr)
+        addr = to_int(addr)
-        size = self._hexint(size)
+        size = to_int(size)
-        keyindex = self._hexint(keyindex)
+        keyindex = to_int(keyindex)
         self.emcore.aesdecrypt(addr, size, keyindex)
     @command
     def hmac_sha1(self, addr, size, destination):
         """
             Generates a HMAC-SHA1 hash of the buffer
             <addr>: the starting address of the buffer
             <size>: the size of the buffer
             <destination>: the location where the key will be stored
         """
-        addr = self._hexint(addr)
+        addr = to_int(addr)
-        size = self._hexint(size)
+        size = to_int(size)
-        destination = self._hexint(destination)
+        destination = to_int(destination)
         sha1size = 0x14
         self.logger.info("Generating hmac-sha1 hash from the buffer at 0x%X with the size 0x%X and saving it to 0x%X - 0x%X\n" %
                         (addr, size, destination, destination + sha1size))
         self.emcore.hmac_sha1(addr, size, destination)
         self.logger.info("done\n")
             <start>: start block
             <count>: block count
             [doecc]: use ecc error correction data
             [checkempty]: set statusflags if pages are empty
         """
-        addr = self._hexint(addr)
+        addr = to_int(addr)
-        start = self._hexint(start)
+        start = to_int(start)
-        count = self._hexint(count)
+        count = to_int(count)
-        doecc = self._bool(doecc)
+        doecc = to_bool(doecc)
-        checkempty = self._bool(checkempty)
+        checkempty = to_bool(checkempty)
         self.logger.info("Reading 0x%X NAND pages starting at 0x%X to memory at 0x%X..." %
                         (count, start, addr))
         self.emcore.ipodnano2g_nandread(addr, start, count, doecc, checkempty)
         self.logger.info("done\n")
             <addr>: the memory location where the data is read from
             <start>: start block
             <count>: block count
             [doecc]: create ecc error correction data
         """
-        addr = self._hexint(addr)
+        addr = to_int(addr)
-        start = self._hexint(start)
+        start = to_int(start)
-        count = self._hexint(count)
+        count = to_int(count)
-        doecc = self._bool(doecc)
+        doecc = to_bool(doecc)
         self.logger.info("Writing 0x%X NAND pages starting at 0x%X from memory at 0x%X..." %
                         (count, start, addr))
         self.emcore.ipodnano2g_nandwrite(addr, start, count, doecc)
         self.logger.info("done\n")
             Erases blocks on the NAND chip and stores the results to memory
             <addr>: the memory location where the results are stored
             <start>: start block
             <count>: block count
         """
-        addr = self._hexint(addr)
+        addr = to_int(addr)
-        start = self._hexint(start)
+        start = to_int(start)
-        count = self._hexint(count)
+        count = to_int(count)
         self.logger.info("Erasing 0x%X NAND pages starting at 0x%X and logging to 0x%X..." %
                         (count, start, addr))
         self.emcore.ipodnano2g_nanderase(addr, start, count)
         self.logger.info("done\n")
         """
             Target-specific function: ipodclassic
             Uploads the bad block table <filename> to
             memory at <tempaddr> and writes it to the hard disk
         """
-        tempaddr = self._hexint(tempaddr)
+        tempaddr = to_int(tempaddr)
         try:
             f = open(filename, 'rb')
         except IOError:
             raise ArgumentError("File not readable. Does it exist?")
         self.logger.info("Writing bad block table to disk...")
     def getvolumeinfo(self, volume):
         """
             Gathers some information about a storage volume used
             <volume>: volume id
         """
-        volume = self._hexint(volume)
+        volume = to_int(volume)
         data = self.emcore.storage_get_info(volume)
         self.logger.info("Sector size: %d\n" % data["sectorsize"])
         self.logger.info("Number of sectors: %d\n" % data["numsectors"])
         self.logger.info("Vendor: %s\n" % data["vendor"])
         self.logger.info("Product: %s\n" % data["product"])
     @command
     def readrawstorage(self, volume, sector, count, addr):
         """
             Reads <count> sectors starting at <sector> from storage <volume> to memory at <addr>.
         """
-        volume = self._hexint(volume)
+        volume = to_int(volume)
-        sector = self._hexint(sector)
+        sector = to_int(sector)
-        count = self._hexint(count)
+        count = to_int(count)
-        addr = self._hexint(addr)
+        addr = to_int(addr)
         self.logger.info("Reading volume %s sectors %X - %X to %08X..." % (volume, sector, sector + count - 1, addr))
         self.emcore.storage_read_sectors_md(volume, sector, count, addr)
         self.logger.info("done\n")
     @command
     def writerawstorage(self, volume, sector, count, addr):
         """
             Writes memory contents at <addr> to <count> sectors starting at <sector> on storage <volume>.
         """
-        volume = self._hexint(volume)
+        volume = to_int(volume)
-        sector = self._hexint(sector)
+        sector = to_int(sector)
-        count = self._hexint(count)
+        count = to_int(count)
-        addr = self._hexint(addr)
+        addr = to_int(addr)
         self.logger.info("Writing %08X to volume %s sectors %X - %X..." % (addr, volume, sector, sector + count - 1))
         self.emcore.storage_write_sectors_md(volume, sector, count, addr)
         self.logger.info("done\n")
     @command
     def readrawstoragefile(self, volume, sector, count, file, buffsize = 0x100000, buffer = None):
         """
             Reads <count> sectors starting at <sector> from storage <volume> to file <file>,
             buffering them in memory at [buffer] in chunks of [buffsize] bytes (both optional).
         """
-        volume = self._hexint(volume)
+        volume = to_int(volume)
-        sector = self._hexint(sector)
+        sector = to_int(sector)
-        count = self._hexint(count)
+        count = to_int(count)
-        buffsize = self._hexint(buffsize)
+        buffsize = to_int(buffsize)
         try:
             f = open(file, 'wb')
         except IOError:
             raise ArgumentError("Could not open local file for writing.")
         try:
             buffsize = min(buffsize, storageinfo.sectorsize * count)
             if buffer is None:
                 buffer = self.emcore.malloc(buffsize)
                 malloc = True
             else:
-                buffer = self._hexint(buffer)
+                buffer = to_int(buffer)
                 malloc = False
             try:
                 self.logger.info("Reading volume %s sectors %X - %X to %s..." % (volume, sector, sector + count - 1, file))
                 while count > 0:
                     sectors = min(count, int(buffsize / storageinfo.sectorsize))
     def writerawstoragefile(self, volume, sector, count, file, buffsize = 0x100000, buffer = None):
         """
             Writes contents of <file> to <count> sectors starting at <sector> on storage <volume>,
             buffering them in memory at [buffer] in chunks of [buffsize] bytes (both optional).
         """
-        volume = self._hexint(volume)
+        volume = to_int(volume)
-        sector = self._hexint(sector)
+        sector = to_int(sector)
-        count = self._hexint(count)
+        count = to_int(count)
-        buffsize = self._hexint(buffsize)
+        buffsize = to_int(buffsize)
         try:
             f = open(file, 'rb')
         except IOError:
             raise ArgumentError("Could not open local file for reading.")
         try:
             buffsize = min(buffsize, storageinfo.sectorsize * count)
             if buffer is None:
                 buffer = self.emcore.malloc(buffsize)
                 malloc = True
             else:
-                buffer = self._hexint(buffer)
+                buffer = to_int(buffer)
                 malloc = False
             try:
                 self.logger.info("Writing %s to volume %s sectors %X - %X..." % (file, volume, sector, sector + count - 1))
                 while count > 0:
                     sectors = min(count, int(buffsize / storageinfo.sectorsize))
             <remotename>: filename on the device
             <localname>: filename on the computer
             [buffsize]: buffer size (optional)
             [buffer]: buffer address (optional)
         """
-        buffsize = self._hexint(buffsize)
+        buffsize = to_int(buffsize)
         try:
             f = open(localname, 'wb')
         except IOError:
             raise ArgumentError("Could not open local file for writing.")
         try:
                 buffsize = min(buffsize, size)
                 if buffer is None:
                     buffer = self.emcore.malloc(buffsize)
                     malloc = True
                 else:
-                    buffer = self._hexint(buffer)
+                    buffer = to_int(buffer)
                     malloc = False
                 try:
                     self.logger.info("Downloading file %s to %s..." % (remotename, localname))
                     while size > 0:
                         bytes = self.emcore.file_read(fd, buffsize, buffer).rc
             <remotepath>: path on the device
             <localpath>: path on the computer
             [buffsize]: buffer size (optional)
             [buffer]: buffer address (optional)
         """
-        buffsize = self._hexint(buffsize)
+        buffsize = to_int(buffsize)
         handle = self.emcore.dir_open(remotepath)
         try:
             if buffer is None:
                 buffer = self.emcore.malloc(buffsize)
                 malloc = True
             else:
-                buffer = self._hexint(buffer)
+                buffer = to_int(buffer)
                 malloc = False
             try:
                 try: os.mkdir(localpath)
                 except: pass
                 while True:
             <localname>: filename on the computer
             <remotename>: filename on the device
             [buffsize]: buffer size (optional)
             [buffer]: buffer address (optional)
         """
-        buffsize = self._hexint(buffsize)
+        buffsize = to_int(buffsize)
         try:
             f = open(localname, 'rb')
         except IOError:
             raise ArgumentError("Could not open local file for reading.")
         try:
             buffsize = min(buffsize, os.path.getsize(localname))
             if buffer is None:
                 buffer = self.emcore.malloc(buffsize)
                 malloc = True
             else:
-                buffer = self._hexint(buffer)
+                buffer = to_int(buffer)
                 malloc = False
             try:
                 self.logger.info("Uploading file %s to %s..." % (localname, remotename))
                 fd = self.emcore.file_open(remotename, 0x15)
                 try:
             <localpath>: path on the computer
             <remotepath>: path on the device
             [buffsize]: buffer size (optional)
             [buffer]: buffer address (optional)
         """
-        buffsize = self._hexint(buffsize)
+        buffsize = to_int(buffsize)
         if buffer is None:
             buffer = self.emcore.malloc(buffsize)
             malloc = True
         else:
-            buffer = self._hexint(buffer)
+            buffer = to_int(buffer)
             malloc = False
         try:
             try: self.mkdir(remotepath)
             except: self.logger.info(" failed\n")
             pathlen = len(localpath)
         self.emcore.dir_close(handle)
     @command
     def malloc(self, size):
         """ Allocates <size> bytes and returns a pointer to the allocated memory """
-        size = self._hexint(size)
+        size = to_int(size)
         self.logger.info("Allocating %d bytes of memory\n" % size)
         addr = self.emcore.malloc(size)
         self.logger.info("Allocated %d bytes of memory at 0x%X\n" % (size, addr))
     @command
     def memalign(self, align, size):
         """ Allocates <size> bytes aligned to <align> and returns a pointer to the allocated memory """
-        align = self._hexint(align)
+        align = to_int(align)
-        size = self._hexint(size)
+        size = to_int(size)
         self.logger.info("Allocating %d bytes of memory aligned to 0x%X\n" % (size, align))
         addr = self.emcore.memalign(align, size)
         self.logger.info("Allocated %d bytes of memory at 0x%X\n" % (size, addr))
     @command
     def realloc(self, ptr, size):
         """ The size of the memory block pointed to by <ptr> is changed to the <size> bytes,
             expanding or reducing the amount of memory available in the block.
             Returns a pointer to the reallocated memory.
         """
-        ptr = self._hexint(ptr)
+        ptr = to_int(ptr)
-        size = self._hexint(size)
+        size = to_int(size)
         self.logger.info("Reallocating 0x%X to have the new size %d\n" % (ptr, size))
         addr = self.emcore.realloc(ptr, size)
         self.logger.info("Reallocated memory at 0x%X to 0x%X with the new size %d\n" % (ptr, addr, size))
     @command
     def reownalloc(self, ptr, owner):
         """ Changes the owner of the memory allocation <ptr> to the thread struct at addr <owner> """
-        ptr = self._hexint(ptr)
+        ptr = to_int(ptr)
-        owner = self._hexint(owner)
+        owner = to_int(owner)
         self.logger.info("Changing owner of the memory region 0x%X to 0x%X\n" % (ptr, owner))
         self.emcore.reownalloc(ptr, owner)
         self.logger.info("Successfully changed owner of 0x%X to 0x%X\n" % (ptr, owner))
     @command
     def free(self, ptr):
         """ Frees the memory space pointed to by 'ptr' """
-        ptr = self._hexint(ptr)
+        ptr = to_int(ptr)
         self.logger.info("Freeing the memory region at 0x%X\n" % ptr)
         self.emcore.free(ptr)
         self.logger.info("Successfully freed the memory region at 0x%X\n" % ptr)
     @command

Subversion Repositories freemyipod

(root)/emcore/trunk/tools/emcore.py @ 532 – Rev 522 → 532