Changeset 04a5204 in rtems-tools


Ignore:
Timestamp:
Nov 12, 2015, 10:15:23 AM (4 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
4.10, master
Children:
c9fa179
Parents:
ab922fe
Message:

Python 3 compatibility

Files:
28 edited

Legend:

Unmodified
Added
Removed
  • rtemstoolkit/check.py

    rab922fe r04a5204  
    156156        log.notice('RTEMS Source Builder - Check, v%s' % (version.str()))
    157157        if host_setup(_opts):
    158             print 'Environment is ok'
     158            print('Environment is ok')
    159159        else:
    160             print 'Environment is not correctly set up'
    161     except error.general, gerr:
    162         print gerr
     160            print('Environment is not correctly set up')
     161    except error.general as gerr:
     162        print(gerr)
    163163        sys.exit(1)
    164     except error.internal, ierr:
    165         print ierr
     164    except error.internal as ierr:
     165        print (ierr)
    166166        sys.exit(1)
    167     except error.exit, eerr:
     167    except error.exit:
    168168        pass
    169169    except KeyboardInterrupt:
  • rtemstoolkit/config.py

    rab922fe r04a5204  
    4949    import path
    5050except KeyboardInterrupt:
    51     print 'user terminated'
     51    print('user terminated')
    5252    sys.exit(1)
    5353except:
    54     print 'error: unknown application load error'
     54    print('error: unknown application load error')
    5555    sys.exit(1)
    5656
     
    138138        trace_me = False
    139139        if trace_me:
    140             print '------------------------------------------------------'
     140            print('------------------------------------------------------')
    141141        macros = []
    142142        nesting = []
     
    145145        while c < len(s):
    146146            if trace_me:
    147                 print 'ms:', c, '"' + s[c:] + '"', has_braces, len(nesting), nesting
     147                print('ms:', c, '"' + s[c:] + '"', has_braces, len(nesting), nesting)
    148148            #
    149149            # We need to watch for shell type variables or the form '${var}' because
     
    193193            c += 1
    194194        if trace_me:
    195             print 'ms:', macros
     195            print('ms:', macros)
    196196        if trace_me:
    197             print '-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-='
     197            print('-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=')
    198198        return macros
    199199
     
    751751            log.trace('config: %s: _open: %s' % (self.init_name, path.host(configname)))
    752752            config = open(path.host(configname), 'r')
    753         except IOError, err:
     753        except IOError as err:
    754754            raise error.general('error opening config file: %s' % (path.host(configname)))
    755755        self.configpath += [configname]
     
    841841        for config_file in opts.config_files():
    842842            s = file(config_file, opts)
    843             print s
     843            print(s)
    844844            del s
    845     except error.general, gerr:
    846         print gerr
     845    except error.general as gerr:
     846        print(gerr)
    847847        sys.exit(1)
    848     except error.internal, ierr:
    849         print ierr
     848    except error.internal as ierr:
     849        print(ierr)
    850850        sys.exit(1)
    851851    except KeyboardInterrupt:
  • rtemstoolkit/error.py

    rab922fe r04a5204  
    5858    try:
    5959        raise general('a general error')
    60     except general, gerr:
    61         print 'caught:', gerr
     60    except general as gerr:
     61        print('caught:', gerr)
    6262    try:
    6363        raise internal('an internal error')
    64     except internal, ierr:
    65         print 'caught:', ierr
     64    except internal as ierr:
     65        print('caught:', ierr)
  • rtemstoolkit/execute.py

    rab922fe r04a5204  
    128128            is a timeout check."""
    129129            if trace_threads:
    130                 print 'executte:_writethread: start'
     130                print('executte:_writethread: start')
    131131            try:
    132132                while True:
     
    143143            except:
    144144                if trace_threads:
    145                     print 'executte:_writethread: exception'
     145                    print('executte:_writethread: exception')
    146146                pass
    147147            try:
     
    150150                pass
    151151            if trace_threads:
    152                 print 'executte:_writethread: finished'
     152                print('executte:_writethread: finished')
    153153
    154154        def _readthread(exe, fh, out, prefix = ''):
     
    168168
    169169            if trace_threads:
    170                 print 'executte:_readthread: start'
     170                print('executte:_readthread: start')
    171171            count = 0
    172172            line = ''
     
    188188                raise
    189189                if trace_threads:
    190                     print 'executte:_readthread: exception'
     190                    print('executte:_readthread: exception')
    191191                pass
    192192            try:
     
    197197                _output_line(line, exe, prefix, out, 100)
    198198            if trace_threads:
    199                 print 'executte:_readthread: finished'
     199                print('executte:_readthread: finished')
    200200
    201201        def _timerthread(exe, interval, function):
     
    346346            if self.verbose:
    347347                log.output('exit: ' + str(exit_code))
    348         except OSError, ose:
     348        except OSError as ose:
    349349            exit_code = ose.errno
    350350            if self.verbose:
     
    454454        try:
    455455            if self.proc is not None:
    456                 print "sending sig"
     456                print("sending sig")
    457457                self.proc.send_signal(signal)
    458458        except:
     
    518518                             capture = False, stdin = subprocess.PIPE)
    519519        if ec == 0:
    520             print 'piping input into ' + commands['pipe'][0] + ': ' + \
    521                   commands['pipe'][2]
     520            print('piping input into ' + commands['pipe'][0] + ': ' + \
     521                  commands['pipe'][2])
    522522            proc.stdin.write(commands['pipe'][2])
    523523            proc.stdin.close()
     
    545545    commands['unix']['pipe'] = ('grep', 'hello', 'hello world')
    546546
    547     print arg_list('cmd a1 a2 "a3 is a string" a4')
    548     print arg_list('cmd b1 b2 "b3 is a string a4')
    549     print arg_subst(['nothing', 'xx-%0-yyy', '%1', '%2-something'],
    550                     ['subst0', 'subst1', 'subst2'])
     547    print(arg_list('cmd a1 a2 "a3 is a string" a4'))
     548    print(arg_list('cmd b1 b2 "b3 is a string a4'))
     549    print(arg_subst(['nothing', 'xx-%0-yyy', '%1', '%2-something'],
     550                    ['subst0', 'subst1', 'subst2']))
    551551
    552552    e = execute(error_prefix = 'ERR: ', verbose = True)
  • rtemstoolkit/git.py

    rab922fe r04a5204  
    193193    opts = options.load(sys.argv)
    194194    g = repo('.', opts)
    195     print g.git_version()
    196     print g.valid()
    197     print g.status()
    198     print g.clean()
    199     print g.remotes()
    200     print g.email()
    201     print g.head()
     195    print(g.git_version())
     196    print(g.valid())
     197    print(g.status())
     198    print(g.clean())
     199    print(g.remotes())
     200    print(g.email())
     201    print(g.head())
  • rtemstoolkit/log.py

    rab922fe r04a5204  
    7575        lock.acquire()
    7676        for l in text.replace(chr(13), '').splitlines():
    77             print l
     77            print(l)
    7878        lock.release()
    7979
     
    9393        lock.acquire()
    9494        for l in text.replace(chr(13), '').splitlines():
    95             print l
     95            print(l)
    9696        lock.release()
    9797    if not stdout_only:
     
    128128                    try:
    129129                        self.fhs.append(file(s, 'w'))
    130                     except IOError, ioe:
     130                    except IOError as ioe:
    131131                         raise error.general("creating log file '" + s + \
    132132                                             "': " + str(ioe))
     
    187187    l.output('log: hello world NONE')
    188188    l.flush()
    189     print '=-' * 40
    190     print 'tail: %d' % (len(l.tail))
    191     print l
    192     print '=-' * 40
     189    print('=-' * 40)
     190    print('tail: %d' % (len(l.tail)))
     191    print(l)
     192    print('=-' * 40)
    193193    for i in range(0, 10):
    194194        l.output('log: hello world 2: %d\n' % (i))
    195195    l.flush()
    196     print '=-' * 40
    197     print 'tail: %d' % (len(l.tail))
    198     print l
    199     print '=-' * 40
     196    print('=-' * 40)
     197    print('tail: %d' % (len(l.tail)))
     198    print(l)
     199    print('=-' * 40)
    200200    for i in [0, 1]:
    201201        quiet = False
    202202        tracing = False
    203         print '- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30)
     203        print('- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30))
    204204        trace('trace with quiet and trace off')
    205205        notice('notice with quiet and trace off')
    206206        quiet = True
    207207        tracing = False
    208         print '- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30)
     208        print('- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30))
    209209        trace('trace with quiet on and trace off')
    210210        notice('notice with quiet on and trace off')
    211211        quiet = False
    212212        tracing = True
    213         print '- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30)
     213        print('- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30))
    214214        trace('trace with quiet off and trace on')
    215215        notice('notice with quiet off and trace on')
    216216        quiet = True
    217217        tracing = True
    218         print '- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30)
     218        print('- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30))
    219219        trace('trace with quiet on and trace on')
    220220        notice('notice with quiet on and trace on')
    221221        default = l
    222     print '=-' * 40
    223     print 'tail: %d' % (len(l.tail))
    224     print l
    225     print '=-' * 40
     222    print('=-' * 40)
     223    print('tail: %d' % (len(l.tail)))
     224    print(l)
     225    print('=-' * 40)
    226226    del l
  • rtemstoolkit/macros.py

    rab922fe r04a5204  
    240240        trace_me = False
    241241        if trace_me:
    242             print '[[[[]]]] parsing macros'
     242            print('[[[[]]]] parsing macros')
    243243        orig_macros = copy.copy(self.macros)
    244244        map = 'global'
     
    255255            for c in l:
    256256                if trace_me:
    257                     print ']]]]]]]] c:%s(%d) s:%s t:"%s" m:%r M:%s' % \
    258                         (c, ord(c), state, token, macro, map)
     257                    print(']]]]]]]] c:%s(%d) s:%s t:"%s" m:%r M:%s' % \
     258                        (c, ord(c), state, token, macro, map))
    259259                l_remaining = l_remaining[1:]
    260260                if c is '#' and not state.startswith('value'):
     
    379379                    self.files += [n]
    380380                    return
    381                 except IOError, err:
     381                except IOError as err:
    382382                    pass
    383383        raise error.general('opening macro file: %s' % \
     
    491491    import copy
    492492    import sys
    493     print inspect.getfile(macros)
     493    print(inspect.getfile(macros))
    494494    m = macros(name = 'defaults.mc')
    495495    d = copy.copy(m)
    496496    m['test1'] = 'something'
    497497    if d.has_key('test1'):
    498         print 'error: copy failed.'
     498        print('error: copy failed.')
    499499        sys.exit(1)
    500500    m.parse("[test]\n" \
    501501            "test1: none, undefine, ''\n" \
    502502            "name:  none, override, 'pink'\n")
    503     print 'set test:', m.set_read_map('test')
     503    print('set test:', m.set_read_map('test'))
    504504    if m['name'] != 'pink':
    505         print 'error: override failed. name is %s' % (m['name'])
     505        print('error: override failed. name is %s' % (m['name']))
    506506        sys.exit(1)
    507507    if m.has_key('test1'):
    508         print 'error: map undefine failed.'
     508        print('error: map undefine failed.')
    509509        sys.exit(1)
    510     print 'unset test:', m.unset_read_map('test')
    511     print m
    512     print m.keys()
     510    print('unset test:', m.unset_read_map('test'))
     511    print(m)
     512    print(m.keys())
  • rtemstoolkit/mailer.py

    rab922fe r04a5204  
    7676                lines = mrc.readlines()
    7777                mrc.close()
    78             except IOError, err:
     78            except IOError as err:
    7979                raise error.general('error reading: %s' % (mailrc))
    8080            for l in lines:
     
    105105            s = smtplib.SMTP(self.smtp_host())
    106106            s.sendmail(from_addr, [to_addr], msg)
    107         except smtplib.SMTPException, se:
     107        except smtplib.SMTPException as se:
    108108            raise error.general('sending mail: %s' % (str(se)))
    109         except socket.error, se:
     109        except socket.error as se:
    110110            raise error.general('sending mail: %s' % (str(se)))
    111111
     
    116116    opts = options.load(sys.argv, optargs = optargs, defaults = 'defaults.mc')
    117117    m = mail(opts)
    118     print 'From: %s' % (m.from_address())
    119     print 'SMTP Host: %s' % (m.smtp_host())
     118    print('From: %s' % (m.from_address()))
     119    print('SMTP Host: %s' % (m.smtp_host()))
    120120    m.send(m.from_address(), 'Test mailer.py', 'This is a test')
  • rtemstoolkit/options.py

    rab922fe r04a5204  
    274274
    275275    def help(self):
    276         print '%s: [options] [args]' % (self.command_name)
    277         print 'RTEMS Tools Project (c) 2012-2015 Chris Johns'
    278         print 'Options and arguments:'
     276        print('%s: [options] [args]' % (self.command_name))
     277        print('RTEMS Tools Project (c) 2012-2015 Chris Johns')
     278        print('Options and arguments:')
    279279        opts = self.long_opts_help.keys()
    280280        if self.optargs:
     
    288288            else:
    289289                raise error.general('invalid help data: %s' %(o))
    290             print '%-*s : %s' % (indent, o, h)
     290            print('%-*s : %s' % (indent, o, h))
    291291        raise error.exit()
    292292
     
    581581        log.notice('Defaults:')
    582582        log.notice(str(opts.defaults))
    583     except error.general, gerr:
    584         print gerr
     583    except error.general as gerr:
     584        print(gerr)
    585585        sys.exit(1)
    586     except error.internal, ierr:
    587         print ierr
     586    except error.internal as ierr:
     587        print(ierr)
    588588        sys.exit(1)
    589     except error.exit, eerr:
     589    except error.exit:
    590590        pass
    591591    except KeyboardInterrupt:
  • rtemstoolkit/path.py

    rab922fe r04a5204  
    123123            try:
    124124                os.makedirs(host(path))
    125             except IOError, err:
    126                 raise error.general('cannot make directory: %s' % (path))
    127             except OSError, err:
    128                 raise error.general('cannot make directory: %s' % (path))
    129             except WindowsError, err:
     125            except IOError:
     126                raise error.general('cannot make directory: %s' % (path))
     127            except OSError:
     128                raise error.general('cannot make directory: %s' % (path))
     129            except WindowsError:
    130130                raise error.general('cannot make directory: %s' % (path))
    131131        else:
    132132            try:
    133133                os.makedirs(host(path))
    134             except IOError, err:
    135                 raise error.general('cannot make directory: %s' % (path))
    136             except OSError, err:
     134            except IOError:
     135                raise error.general('cannot make directory: %s' % (path))
     136            except OSError:
    137137                raise error.general('cannot make directory: %s' % (path))
    138138
     
    140140
    141141    def _onerror(function, path, excinfo):
    142         print 'removeall error: (%s) %s' % (excinfo, path)
     142        print('removeall error: (%s) %s' % (excinfo, path))
    143143
    144144    path = host(path)
     
    209209            else:
    210210                shutil.copy2(srcname, dstname)
    211         except shutil.Error, err:
     211        except shutil.Error as err:
    212212            raise error.general('copying tree: %s -> %s: %s' % (src, dst, str(err)))
    213         except EnvironmentError, why:
     213        except EnvironmentError as why:
    214214            raise error.general('copying tree: %s -> %s: %s' % (srcname, dstname, str(why)))
    215215    try:
    216216        shutil.copystat(src, dst)
    217     except OSError, why:
     217    except OSError as why:
    218218        ok = False
    219219        if windows:
     
    224224
    225225if __name__ == '__main__':
    226     print host('/a/b/c/d-e-f')
    227     print host('//a/b//c/d-e-f')
    228     print shell('/w/x/y/z')
    229     print basename('/as/sd/df/fg/me.txt')
    230     print dirname('/as/sd/df/fg/me.txt')
    231     print join('/d', 'g', '/tyty/fgfg')
     226    print(host('/a/b/c/d-e-f'))
     227    print(host('//a/b//c/d-e-f'))
     228    print(shell('/w/x/y/z'))
     229    print(basename('/as/sd/df/fg/me.txt'))
     230    print(dirname('/as/sd/df/fg/me.txt'))
     231    print(join('/d', 'g', '/tyty/fgfg'))
    232232    windows = True
    233     print host('/a/b/c/d-e-f')
    234     print host('//a/b//c/d-e-f')
    235     print shell('/w/x/y/z')
    236     print shell('w:/x/y/z')
    237     print basename('x:/sd/df/fg/me.txt')
    238     print dirname('x:/sd/df/fg/me.txt')
    239     print join('s:/d/', '/g', '/tyty/fgfg')
     233    print(host('/a/b/c/d-e-f'))
     234    print(host('//a/b//c/d-e-f'))
     235    print(shell('/w/x/y/z'))
     236    print(shell('w:/x/y/z'))
     237    print(basename('x:/sd/df/fg/me.txt'))
     238    print(dirname('x:/sd/df/fg/me.txt'))
     239    print(join('s:/d/', '/g', '/tyty/fgfg'))
  • rtemstoolkit/version.py

    rab922fe r04a5204  
    4343
    4444if __name__ == '__main__':
    45     print 'major = %d' % (major)
    46     print 'minor = %d' % (minor)
    47     print 'revision = %d' % (revision)
    48     print 'Version: %s' % (str())
     45    print('major = %d' % (major))
     46    print('minor = %d' % (minor))
     47    print('revision = %d' % (revision))
     48    print('Version: %s' % (str()))
  • tester/rt/config.py

    rab922fe r04a5204  
    186186        if self.realtime_trace:
    187187            for l in text:
    188                 print ' '.join(l)
     188                print(' '.join(l))
    189189
    190190    def run(self):
  • tester/rt/console.py

    rab922fe r04a5204  
    101101        super(tty, self).__del__()
    102102        if self._tracing():
    103             print ':: tty close', self.dev
     103            print(':: tty close', self.dev)
    104104        if fcntl is not None:
    105105            fcntl.fcntl(me.tty.fd, fcntl.F_SETFL,
     
    110110        def _readthread(me, x):
    111111            if self._tracing():
    112                 print ':: tty runner started', self.dev
     112                print(':: tty runner started', self.dev)
    113113            if fcntl is not None:
    114114                fcntl.fcntl(me.tty.fd, fcntl.F_SETFL,
     
    119119                try:
    120120                    data = me.tty.fd.read()
    121                 except IOError, ioe:
     121                except IOError as ioe:
    122122                    if ioe.errno == errno.EAGAIN:
    123123                        continue
     
    134134                        line = ''
    135135            if self._tracing():
    136                 print ':: tty runner finished', self.dev
     136                print(':: tty runner finished', self.dev)
    137137        if self._tracing():
    138             print ':: tty open', self.dev
     138            print(':: tty open', self.dev)
    139139        self.tty = stty.tty(self.dev)
    140140        self.tty.set(self.setup)
  • tester/rt/gdb.py

    rab922fe r04a5204  
    7777    def _lock(self, msg):
    7878        if self.lock_trace:
    79             print '|[   LOCK:%s ]|' % (msg)
     79            print('|[   LOCK:%s ]|' % (msg))
    8080        self.lock.acquire()
    8181
    8282    def _unlock(self, msg):
    8383        if self.lock_trace:
    84             print '|] UNLOCK:%s [|' % (msg)
     84            print('|] UNLOCK:%s [|' % (msg))
    8585        self.lock.release()
    8686
     
    9393    def _put(self, text):
    9494        if self.trace:
    95             print ')))', text
     95            print(')))', text)
    9696        self.commands.put(text)
    9797
     
    101101        try:
    102102            if self.trace:
    103                 print '... input empty ', self.input.empty()
     103                print('... input empty ', self.input.empty())
    104104            if self.input.empty():
    105105                line = self.commands.get(block = False)
    106106                if self.trace:
    107                     print '+++', line
     107                    print('+++', line)
    108108                self.input.put(line)
    109109        except:
     
    114114        self._lock('_reader')
    115115        if self.trace:
    116             print '<<<', line
     116            print('<<<', line)
    117117        try:
    118118            self.lc += 1
    119119            if line.startswith('(gdb)'):
    120120                if self.trace:
    121                     print '^^^ (gdb)'
     121                    print('^^^ (gdb)')
    122122                if not self._input_commands():
    123123                    self.gdb_expect()
     
    139139                line = self.input.get(timeout = 0.5)
    140140                if self.trace:
    141                     print '>>> input: queue=%d' % (self.input.qsize()), line
     141                    print('>>> input: queue=%d' % (self.input.qsize()), line)
    142142            except Queue.Empty:
    143143                return True
     
    147147        except:
    148148            if self.trace:
    149                 print 'writer exception'
     149                print('writer exception')
    150150            pass
    151151        if self.trace:
    152             print 'writer closing'
     152            print('writer closing')
    153153        return False
    154154
     
    207207            ec, proc = self.process.open(cmds, timeout = (timeout, self._timeout))
    208208            if self.trace:
    209                 print 'gdb done', ec
     209                print('gdb done', ec)
    210210            if ec > 0:
    211211                raise error.general('gdb exec: %s: %s' % (cmds[0], os.strerror(ec)))
     
    220220    def gdb_expect(self):
    221221        if self.trace:
    222             print '}}} gdb-expect'
     222            print('}}} gdb-expect')
    223223        if self.process and not self.running and self.script is not None:
    224224            if self.script_line == len(self.script):
     
    239239            try:
    240240                if self.mi_trace:
    241                     print 'mi-data:', lines
     241                    print('mi-data:', lines)
    242242                rec = pygdb.mi_parser.process(lines)
    243243            finally:
    244244                self._mi_unlock()
    245245            if self.mi_trace:
    246                 print 'mi-rec:', rec
     246                print('mi-rec:', rec)
    247247            if rec.record_type == 'result':
    248248                if rec.type == 'result':
     
    256256                    if rec.class_ == 'running':
    257257                        if self.trace:
    258                             print '*** running'
     258                            print('*** running')
    259259                        self._put('')
    260260                        self.running = True
    261261                    elif rec.class_ == 'stopped':
    262262                        if self.trace:
    263                             print '*** stopped'
     263                            print('*** stopped')
    264264                        self.running = False
    265265                        #self._put('-data-list-register-values')
     
    284284                        lines = self.output_buffer[:last_lf]
    285285                        if self.trace:
    286                             print '/// console output'
     286                            print('/// console output')
    287287                        for line in lines.splitlines():
    288288                            self.output(line)
     
    290290        except:
    291291            if self.trace:
    292                 print '/// console output'
     292                print('/// console output')
    293293            for line in lines.splitlines():
    294294                self.output(line)
     
    298298    try:
    299299        def output(text):
    300             print ']', text
     300            print(']', text)
    301301        def gdb_console(text):
    302             print '>', text
     302            print('>', text)
    303303        script = ['target sim']
    304304        if len(sys.argv) > 1:
  • tester/rt/options.py

    rab922fe r04a5204  
    115115        log.notice('Defaults:')
    116116        log.notice(str(_opts.defaults))
    117     except error.general, gerr:
    118         print gerr
     117    except error.general as gerr:
     118        print(gerr)
    119119        sys.exit(1)
    120     except error.internal, ierr:
    121         print ierr
     120    except error.internal as ierr:
     121        print(ierr)
    122122        sys.exit(1)
    123     except error.exit, eerr:
     123    except error.exit:
    124124        pass
    125125    except KeyboardInterrupt:
  • tester/rt/pygdb/mi_parser.py

    rab922fe r04a5204  
    9494                def t_default(self, s):
    9595                        r'( . | \n )+'
    96                         raise Exception, "Specification error: unmatched input for '%s'" % s
     96                        raise Exception("Specification error: unmatched input for '%s'" % s)
    9797
    9898                def __unescape(self, s):
     
    168168                def error(self, token, i=0, tokens=None):
    169169                        if i > 2:
    170                                 print '%s %s %s %s' % (tokens[i-3], tokens[i-2], tokens[i-1], tokens[i])
    171                         raise Exception, "Syntax error at or near %d:'%s' token" % (i, token)
     170                                print('%s %s %s %s' % (tokens[i-3], tokens[i-2], tokens[i-1], tokens[i]))
     171                        raise Exception("Syntax error at or near %d:'%s' token" % (i, token))
    172172
    173173        class GdbMiInterpreter(spark.GenericASTTraversal):
     
    191191                        # result ::= variable = value
    192192                        node.value = { node[0].value: node[2].value }
    193                         #print 'result: %s' % node.value
     193                        #print('result: %s' % node.value)
    194194
    195195                def n_tuple(self, node):
     
    206206                                        for n, v in result.items():
    207207                                                if node.value.has_key(n):
    208                                                         #print '**********list conversion: [%s] %s -> %s' % (n, node.value[n], v)
     208                                                        #print('**********list conversion: [%s] %s -> %s' % (n, node.value[n], v))
    209209                                                        old = node.value[n]
    210210                                                        if not isinstance(old, list):
     
    214214                                                        node.value[n] = v
    215215                        else:
    216                                 raise Exception, 'Invalid tuple'
    217                         #print 'tuple: %s' % node.value
     216                                raise Exception('Invalid tuple')
     217                        #print('tuple: %s' % node.value)
    218218
    219219                def n_list(self, node):
     
    231231                                #list ::= { value }
    232232                                #list ::= { value value_list }
    233                         #print 'list %s' % node.value
     233                        #print('list %s' % node.value)
    234234
    235235                def n_value_list(self, node):
     
    248248                                # result_list ::= , result result_list
    249249                                node.value = [ node[1].value ] + node[2].value
    250                         #print 'result_list: %s' % node.value
     250                        #print('result_list: %s' % node.value)
    251251
    252252                def n_result_record(self, node):
     
    258258                                # result_record ::= result_header nl
    259259                                pass
    260                         #print 'result_record: %s' % (node.value)
     260                        #print('result_record: %s' % (node.value))
    261261
    262262                def n_result_header(self, node):
     
    285285                                'record_type': 'stream'
    286286                        }
    287                         #print 'stream_record: %s' % node.value
     287                        #print('stream_record: %s' % node.value)
    288288
    289289                def n_record_list(self, node):
     
    294294                                # record_list ::= generic_record record_list
    295295                                node.value = [ node[0].value ] + node[1].value
    296                         #print 'record_list: %s' % node.value
     296                        #print('record_list: %s' % node.value)
    297297
    298298                #def default(self, node):
    299                         #print 'default: ' + node.type
     299                        #print('default: ' + node.type)
    300300
    301301        class GdbDynamicObject:
     
    364364def process(input):
    365365        tokens = scan(input)
    366         ast = parse(tokens)
     366        ast = parse(tokens)
    367367        __the_interpreter(ast)
    368368        return __the_output(ast.value)
     
    374374                        for token in tokens:
    375375                                if token.value:
    376                                         print token.type + ': ' + token.value
     376                                        print(token.type + ': ' + token.value)
    377377                                else:
    378                                         print token.type
     378                                        print(token.type)
    379379
    380380                def run_test(test):
     
    387387                                __the_interpreter(ast)
    388388                                output = __the_output(ast.value)
    389                                 print output
     389                                print(output)
    390390
    391391                x = '"No symbol table is loaded.  Use the \\"file\\" command."'
  • tester/rt/pygdb/spark.py

    rab922fe r04a5204  
    6161
    6262        def error(self, s, pos):
    63                 print "Lexical error at position %s" % pos
     63                print("Lexical error at position %s" % pos)
    6464                raise SystemExit
    6565
     
    8787        def t_default(self, s):
    8888                r'( . | \n )+'
    89                 print "Specification error: unmatched input"
     89                print("Specification error: unmatched input")
    9090                raise SystemExit
    9191
     
    304304
    305305        def error(self, token):
    306                 print "Syntax error at or near `%s' token" % token
     306                print("Syntax error at or near `%s' token" % token)
    307307                raise SystemExit
    308308
     
    350350                return self._NULLABLE == sym[0:len(self._NULLABLE)]
    351351
    352         def skip(self, (lhs, rhs), pos=0):
     352        def skip(self, lhs_rhs, pos=0):
     353                lhs, rhs = lhs_rhs
    353354                n = len(rhs)
    354355                while pos < n:
     
    613614                else:
    614615                        rule = self.newrules[nt][0]
    615                 #print rule
     616                #print(rule)
    616617
    617618                rhs = rule[1]
     
    632633                if len(choices) > 1:
    633634                        rule = self.ambiguity(choices)
    634                 #print rule
     635                #print(rule)
    635636
    636637                rhs = rule[1]
     
    669670                        name2index[name] = i
    670671                sortlist.sort()
    671                 list = map(lambda (a,b): b, sortlist)
     672                list = list(map(lambda a,b: b, sortlist))
    672673                return rules[name2index[self.resolve(list)]]
    673674
     
    834835def _dump(tokens, sets, states):
    835836        for i in range(len(sets)):
    836                 print 'set', i
     837                print('set', i)
    837838                for item in sets[i]:
    838                         print '\t', item
     839                        print('\t', item)
    839840                        for (lhs, rhs), pos in states[item[0]].items:
    840                                 print '\t\t', lhs, '::=',
    841                                 print string.join(rhs[:pos]),
    842                                 print '.',
    843                                 print string.join(rhs[pos:])
     841                                print('\t\t', lhs, '::=',)
     842                                print(string.join(rhs[:pos]),)
     843                                print('.',)
     844                                print(string.join(rhs[pos:]))
    844845                if i < len(tokens):
    845846                        print
    846                         print 'token', str(tokens[i])
     847                        print('token', str(tokens[i]))
    847848                        print
  • tester/rt/stty.py

    rab922fe r04a5204  
    7373        try:
    7474            self.fd = open(dev, 'rw')
    75         except IOError, ioe:
     75        except IOError as ioe:
    7676            raise error.general('opening tty dev: %s: %s' % (dev, ioe))
    7777        except:
     
    559559        t.vmin(1)
    560560        t.vtime(2)
    561         print t
     561        print(t)
    562562        t.set('B115200,~BRKINT,IGNBRK,IGNCR,~ICANON,~ISIG,~IEXTEN,~ECHO,CLOCAL,~CRTSCTS')
    563         print t
     563        print(t)
    564564        t.on()
    565565        while True:
  • tester/rt/test.py

    rab922fe r04a5204  
    119119    def reraise(self):
    120120        if self.result is not None:
    121             raise self.result[0], self.result[1], self.result[2]
     121            raise (self.result[0], self.result[1], self.result[2])
    122122
    123123    def kill(self):
     
    158158            del reported[:]
    159159            if job_trace:
    160                 print '}} threading:', threading.active_count()
     160                print('}} threading:', threading.active_count())
    161161                for t in threading.enumerate():
    162                     print '}} ', t.name
     162                    print('}} ', t.name)
    163163    return reporting
    164164
     
    303303        log.notice('Average test time: %s' % (str((end_time - start_time) / total)))
    304304        log.notice('Testing time     : %s' % (str(end_time - start_time)))
    305     except error.general, gerr:
    306         print gerr
     305    except error.general as gerr:
     306        print(gerr)
    307307        sys.exit(1)
    308     except error.internal, ierr:
    309         print ierr
     308    except error.internal as ierr:
     309        print(ierr)
    310310        sys.exit(1)
    311     except error.exit, eerr:
     311    except error.exit:
    312312        sys.exit(2)
    313313    except KeyboardInterrupt:
    314314        if opts is not None and opts.find_arg('--stacktrace'):
    315             print '}} dumping:', threading.active_count()
     315            print('}} dumping:', threading.active_count())
    316316            for t in threading.enumerate():
    317                 print '}} ', t.name
    318             print stacktraces.trace()
     317                print('}} ', t.name)
     318            print(stacktraces.trace())
    319319        log.notice('abort: user terminated')
    320320        killall(tests)
  • tester/rt/version.py

    rab922fe r04a5204  
    4343
    4444if __name__ == '__main__':
    45     print 'major = %d' % (major)
    46     print 'minor = %d' % (minor)
    47     print 'revision = %d' % (revision)
    48     print 'Version: %s' % (str())
     45    print('major = %d' % (major))
     46    print('minor = %d' % (minor))
     47    print('revision = %d' % (revision))
     48    print('Version: %s' % (str()))
  • tools/gdb/python/__init__.py

    rab922fe r04a5204  
    3838_cmds = rtems.create()
    3939
    40 print 'RTEMS GDB Support'
     40print('RTEMS GDB Support')
  • tools/gdb/python/classic.py

    rab922fe r04a5204  
    148148    def show(self, from_tty):
    149149        if self.object_control.id() != 0:
    150             print '     Name:', self.object_control.name()
    151             print '       Id: 0x%08x (@ 0x%08x)' % (self.object_control.id(),
    152                                                    self.reference)
    153             print '     Attr:', self.attr.to_string()
     150            print('     Name:', self.object_control.name())
     151            print('       Id: 0x%08x (@ 0x%08x)' % (self.object_control.id(),
     152                                                   self.reference))
     153            print('     Attr:', self.attr.to_string())
    154154            if self.attr.test('semaphore-type', 'bin-sema') or \
    155155               self.attr.test('semaphore-type', 'simple-bin-sema'):
    156156                core_mutex = mutex.control(self.object['Core_control']['mutex'])
    157                 print '  Nesting:', core_mutex.nest_count()
    158                 print '   Holder:',
     157                print('  Nesting:', core_mutex.nest_count())
     158                print('   Holder:',)
    159159                holder = core_mutex.holder()
    160160                if holder:
    161                     print '%s (id 0x%08x)' % (holder.brief(), holder.id())
     161                    print('%s (id 0x%08x)' % (holder.brief(), holder.id()))
    162162                else:
    163                     print 'no holder (unlocked)'
     163                    print('no holder (unlocked)')
    164164                wait_queue = core_mutex.wait_queue()
    165165                tasks = wait_queue.tasks()
    166                 print '    Queue: len = %d, state = %s' % (len(tasks),
    167                                                            wait_queue.state())
     166                print('    Queue: len = %d, state = %s' % (len(tasks),
     167                                                           wait_queue.state()))
    168168                if len(tasks) > 0:
    169                     print '    Tasks:'
    170                     print '    Name (c:current, r:real), (id)'
     169                    print('    Tasks:')
     170                    print('    Name (c:current, r:real), (id)')
    171171                    for t in range(0, len(tasks)):
    172                         print '      ', tasks[t].brief(), ' (%08x)' % (tasks[t].id())
     172                        print('      ', tasks[t].brief(), ' (%08x)' % (tasks[t].id()))
    173173                return True
    174174        return False
     
    190190            if cpu == -1:
    191191                cpu = 'not executing'
    192             print '         Id:', '0x%08x (@ 0x%08x)' % (self.task.id(),
    193                                                          self.task.reference)
    194             print '       Name:', self.task.name()
    195             print ' Active CPU:', cpu
    196             print '      State:', self.task.current_state()
    197             print '    Current:', self.task.current_priority()
    198             print '       Real:', self.task.real_priority()
    199             print '    Preempt:', self.task.preemptible()
    200             print '   T Budget:', self.task.cpu_time_budget()
    201             print '       Time:', self.task.cpu_time_used()
    202             print '  Resources:', self.task.resource_count()
    203             print '  Regsters:'
     192            print('         Id:', '0x%08x (@ 0x%08x)' % (self.task.id(),
     193                                                         self.task.reference))
     194            print('       Name:', self.task.name())
     195            print(' Active CPU:', cpu)
     196            print('      State:', self.task.current_state())
     197            print('    Current:', self.task.current_priority())
     198            print('       Real:', self.task.real_priority())
     199            print('    Preempt:', self.task.preemptible())
     200            print('   T Budget:', self.task.cpu_time_budget())
     201            print('       Time:', self.task.cpu_time_used())
     202            print('  Resources:', self.task.resource_count())
     203            print('  Regsters:')
    204204            for name in self.regs.names():
    205205                val = self.regs.get(name)
    206                 print '    %20s: %08x (%d)' % (name, val, val)
     206                print('    %20s: %08x (%d)' % (name, val, val))
    207207            return True
    208208        return False
     
    223223
    224224    def show(self, from_tty):
    225         print '     Name:', self.object_control.name()
    226         print '     Attr:', self.attr.to_string()
     225        print('     Name:', self.object_control.name())
     226        print('     Attr:', self.attr.to_string())
    227227
    228228        self.core_control.show()
     
    238238
    239239    def show(self, from_tty):
    240         print '     Name:', self.object_control.name()
     240        print('     Name:', self.object_control.name())
    241241        self.watchdog.show()
    242242
     
    256256    def show(self, from_tty):
    257257        # ToDo: the printing still somewhat crude.
    258         print '     Name:', self.object_control.name()
    259         print '     Attr:', self.attr.to_string()
    260         print '   Length:', self.length
    261         print '   B Size:', self.buffer_size
    262         print ' U Blocks:', self.used_blocks
     258        print('     Name:', self.object_control.name())
     259        print('     Attr:', self.attr.to_string())
     260        print('   Length:', self.length)
     261        print('   B Size:', self.buffer_size)
     262        print(' U Blocks:', self.used_blocks)
    263263
    264264class region:
     
    274274
    275275    def show(self, from_tty):
    276         print '     Name:', self.object_control.name()
    277         print '     Attr:', self.attr.to_string()
     276        print('     Name:', self.object_control.name())
     277        print('     Attr:', self.attr.to_string())
    278278        helper.tasks_printer_routine(self.wait_queue)
    279         print '   Memory:'
     279        print('   Memory:')
    280280        self.heap.show()
    281281
     
    291291
    292292    def show(self,from_tty):
    293         print '     Name:',self.object_control.name()
    294         print '     Attr:',self.attr.to_string()
     293        print('     Name:',self.object_control.name())
     294        print('     Attr:',self.attr.to_string())
    295295
    296296        if self.attr.test('barrier','barrier-auto-release'):
    297297            max_count = self.core_b_control.max_count()
    298             print 'Aut Count:', max_count
    299 
    300         print '  Waiting:',self.core_b_control.waiting_threads()
     298            print('Aut Count:', max_count)
     299
     300        print('  Waiting:',self.core_b_control.waiting_threads())
    301301        helper.tasks_printer_routine(self.core_b_control.tasks())
  • tools/gdb/python/heaps.py

    rab922fe r04a5204  
    7474
    7575    def show(self):
    76         print '  Instance:',self.inst()
    77         print '     Avail:',self.avail()
    78         print '      Free:',self.free()
     76        print('  Instance:',self.inst())
     77        print('     Avail:',self.avail())
     78        print('      Free:',self.free())
    7979
    8080    # ToDo : incorporate others
     
    106106        la = self.last()
    107107
    108         print '     First:', fi.val()
    109         print '      Last:', la.val()
     108        print('     First:', fi.val())
     109        print('      Last:', la.val())
    110110
    111111        stats = self.stat()
    112         print '    stats:'
     112        print('    stats:')
    113113        stats.show()
  • tools/gdb/python/helper.py

    rab922fe r04a5204  
    3535def tasks_printer_routine(wait_queue):
    3636    tasks = wait_queue.tasks()
    37     print '    Queue: len = %d, state = %s' % (len(tasks),wait_queue.state())
     37    print('    Queue: len = %d, state = %s' % (len(tasks),wait_queue.state()))
    3838    for t in range(0, len(tasks)):
    39         print '      ', tasks[t].brief(), ' (%08x)' % (tasks[t].id())
     39        print('      ', tasks[t].brief(), ' (%08x)' % (tasks[t].id()))
    4040
    4141def type_from_value(val):
  • tools/gdb/python/rtems.py

    rab922fe r04a5204  
    7979                num = int(val)
    8080            except:
    81                 print 'error: "%s" is not a number' % (num)
     81                print('error: "%s" is not a number' % (num))
    8282                return True
    8383            id = objects.ident(num)
    8484            if not id.valid():
    85                 print 'Invalid object id'
     85                print('Invalid object id')
    8686                return True
    8787
    88             print 'API:%s Class:%s Node:%d Index:%d Id:%08X' % \
    89                 (id.api(), id._class(), id.node(), id.index(), id.value())
     88            print('API:%s Class:%s Node:%d Index:%d Id:%08X' % \
     89                (id.api(), id._class(), id.node(), id.index(), id.value()))
    9090            objectname = id.api() + '/' + id._class()
    9191
     
    125125                    if index < maximum:
    126126                        if index < minimum_id.index():
    127                             print "error: %s is not an index (min is %d)" % (val,
    128                                                                              minimum_id.index())
     127                            print("error: %s is not an index (min is %d)" % (val,
     128                                                                             minimum_id.index()))
    129129                            return
    130130                    else:
    131131                        index = objects.ident(index).index()
    132132                except ValueError:
    133                     print "error: %s is not an index" % (val)
     133                    print("error: %s is not an index" % (val))
    134134                    return
    135135                try:
     
    138138                                                            index)
    139139                except IndexError:
    140                     print "error: index %s is invalid" % (index)
     140                    print("error: index %s is invalid" % (index))
    141141                    return
    142142                instance = self.instance(obj)
     
    144144            objects.information.invalidate()
    145145        else:
    146             print '-' * 70
    147             print ' %s: %d [%08x -> %08x]' % (objects.information.name(self.api, self._class),
    148                                              maximum, minimum_id.value(), maximum_id.value())
     146            print('-' * 70)
     147            print(' %s: %d [%08x -> %08x]' % (objects.information.name(self.api, self._class),
     148                                             maximum, minimum_id.value(), maximum_id.value()))
    149149            valid = True
    150150            for index in range(minimum_id.index(), minimum_id.index() + maximum):
    151151                if valid:
    152                     print '-' * 70
     152                    print('-' * 70)
    153153                valid = self.invoke(str(index), from_tty)
    154154        return valid
     
    250250    def invoke(self, arg, from_tty):
    251251        if arg:
    252             print "warning: commad takes no arguments!"
     252            print("warning: commad takes no arguments!")
    253253        obj = objects.information.object_return(self.api, self._class)
    254254        instance = supercore.time_of_day(obj)
     
    272272
    273273        if inst.empty():
    274             print '     error: empty chain'
     274            print('     error: empty chain')
    275275            return
    276276
     
    279279        while not nd.null():
    280280            wd = watchdog.control(nd.cast('Watchdog_Control'))
    281             print ' #'+str(i)
    282             print wd.to_string()
     281            print(' #'+str(i))
     282            print(wd.to_string())
    283283            nd.next()
    284284            i += 1
  • tools/gdb/python/sparc.py

    rab922fe r04a5204  
    115115
    116116    def show(self):
    117         print '         Global Regs:',
    118         print ' [',
     117        print('         Global Regs:',)
     118        print(' [',)
    119119        for i in self.global_regs():
    120             print str(i)+',',
    121         print '\b\b ]'
     120            print(str(i)+',',)
     121        print('\b\b ]')
    122122
    123         print '          Local Regs:',
    124         print ' [',
     123        print('          Local Regs:',)
     124        print(' [',)
    125125        for i in self.local_regs():
    126             print str(i)+',',
    127         print '\b\b ]'
     126            print(str(i)+',',)
     127        print('\b\b ]')
    128128
    129         print '             In Regs:',
    130         print ' [',
     129        print('             In Regs:',)
     130        print(' [',)
    131131        for i in self.in_regs():
    132             print str(i)+',',
    133         print '\b\b ]'
     132            print(str(i)+',',)
     133        print('\b\b ]')
    134134
    135         print '            Out Regs:',
    136         print ' [',
     135        print('            Out Regs:',)
     136        print(' [',)
    137137        for i in self.out_regs():
    138             print str(i)+',',
    139         print '\b\b ]'
     138            print(str(i)+',',)
     139        print('\b\b ]')
    140140
    141141        sr = self.status()
    142         print sr.to_string()
     142        print(sr.to_string())
  • tools/gdb/python/supercore.py

    rab922fe r04a5204  
    5151
    5252    def show(self):
    53         print ' Time Of Day'
     53        print(' Time Of Day')
    5454
    5555        if not self.is_set():
    56             print ' Application has not set a TOD'
     56            print(' Application has not set a TOD')
    5757
    58         print '      Now:', self.now()
    59         print '   Uptime:', self.timer()
     58        print('      Now:', self.now())
     59        print('   Uptime:', self.timer())
    6060
    6161
  • tools/gdb/python/watchdog.py

    rab922fe r04a5204  
    9090
    9191    def show(self):
    92         print self.to_string()
     92        print(self.to_string())
Note: See TracChangeset for help on using the changeset viewer.