Changeset 4001a74 in rtems-tools


Ignore:
Timestamp:
Mar 2, 2016, 9:54:06 AM (3 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.11
Children:
6359063
Parents:
a4c070c
git-author:
Chris Johns <chrisj@…> (03/02/16 09:54:06)
git-committer:
Chris Johns <chrisj@…> (03/03/16 05:52:32)
Message:

Update rtems-tool to support Python 2 and 3.

Add solaris and netbsd.

Close #2619.

Files:
2 added
28 edited

Legend:

Unmodified
Added
Removed
  • rtemstoolkit/__init__.py

    ra4c070c r4001a74  
    3838       'mailer',
    3939       'options',
    40        'path']
     40       'path',
     41       'version']
     42
     43from . import check
     44from . import config
     45from . import error
     46from . import execute
     47from . import git
     48from . import log
     49from . import macros
     50from . import mailer
     51from . import options
     52from . import path
     53from . import version
  • rtemstoolkit/check.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2010-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2010-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3333#
    3434
     35from __future__ import print_function
     36
    3537import os
    3638
    37 import error
    38 import execute
    39 import log
    40 import options
    41 import path
    42 import version
     39#
     40# Support to handle use in a package and as a unit test.
     41# If there is a better way to let us know.
     42#
     43try:
     44    from . import error
     45    from . import execute
     46    from . import log
     47    from . import options
     48    from . import path
     49    from . import version
     50except (ValueError, SystemError):
     51    import error
     52    import execute
     53    import log
     54    import options
     55    import path
     56    import version
    4357
    4458def _check_none(_opts, macro, value, constraint):
     
    118132    sane = True
    119133
    120     for d in opts.defaults.keys():
     134    for d in list(opts.defaults.keys()):
    121135        try:
    122136            (test, constraint, value) = opts.defaults.get(d)
     
    156170        log.notice('RTEMS Source Builder - Check, v%s' % (version.str()))
    157171        if host_setup(_opts):
    158             print 'Environment is ok'
     172            print('Environment is ok')
    159173        else:
    160             print 'Environment is not correctly set up'
    161     except error.general, gerr:
    162         print gerr
     174            print('Environment is not correctly set up')
     175    except error.general as gerr:
     176        print(gerr)
    163177        sys.exit(1)
    164     except error.internal, ierr:
    165         print ierr
     178    except error.internal as ierr:
     179        print(ierr)
    166180        sys.exit(1)
    167     except error.exit, eerr:
     181    except error.exit as eerr:
    168182        pass
    169183    except KeyboardInterrupt:
  • rtemstoolkit/config.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2010-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2010-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3737#
    3838
     39from __future__ import print_function
     40
    3941import copy
     42import functools
    4043import os
    4144import re
    4245import sys
    4346
     47#
     48# Support to handle use in a package and as a unit test.
     49# If there is a better way to let us know.
     50#
    4451try:
     52    from . import error
     53    from . import execute
     54    from . import log
     55    from . import options
     56    from . import path
     57except (ValueError, SystemError):
    4558    import error
    4659    import execute
     
    4861    import options
    4962    import path
    50 except KeyboardInterrupt:
    51     print 'user terminated'
    52     sys.exit(1)
    53 except:
    54     print 'error: unknown application load error'
    55     sys.exit(1)
    5663
    5764def _check_bool(value):
     
    9198        self._includes = []
    9299        self.load_depth = 0
     100        self.lc = 0
     101        self.name = 'none'
    93102
    94103    def __del__(self):
     
    99108        def _dict(dd):
    100109            s = ''
    101             ddl = dd.keys()
     110            ddl = list(dd.keys())
    102111            ddl.sort()
    103112            for d in ddl:
     
    138147        trace_me = False
    139148        if trace_me:
    140             print '------------------------------------------------------'
     149            print('------------------------------------------------------')
    141150        macros = []
    142151        nesting = []
     
    145154        while c < len(s):
    146155            if trace_me:
    147                 print 'ms:', c, '"' + s[c:] + '"', has_braces, len(nesting), nesting
     156                print('ms:', c, '"' + s[c:] + '"', has_braces, len(nesting), nesting)
    148157            #
    149158            # We need to watch for shell type variables or the form '${var}' because
     
    193202            c += 1
    194203        if trace_me:
    195             print 'ms:', macros
     204            print('ms:', macros)
    196205        if trace_me:
    197             print '-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-='
     206            print('-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=')
    198207        return macros
    199208
     
    433442                    istrue = _check_bool(ifls[0])
    434443                    if istrue == None:
    435                         self._error('invalid if bool value: ' + reduce(add, ls, ''))
     444                        self._error('invalid if bool value: ' + functools.reduce(add, ls, ''))
    436445                        istrue = False
    437446            elif len(ifls) == 2:
     
    439448                    istrue = _check_bool(ifls[1])
    440449                    if istrue == None:
    441                         self._error('invalid if bool value: ' + reduce(add, ls, ''))
     450                        self._error('invalid if bool value: ' + functools.reduce(add, ls, ''))
    442451                        istrue = False
    443452                    else:
     
    455464                        istrue = True
    456465                    else:
    457                         self._error('invalid if bool operator: ' + reduce(add, ls, ''))
     466                        self._error('invalid if bool operator: ' + functools.reduce(add, ls, ''))
    458467            elif len(ifls) == 3:
    459468                if ifls[1] == '==':
     
    488497                        istrue = False
    489498                else:
    490                     self._error('invalid %if operator: ' + reduce(add, ls, ''))
    491             else:
    492                 self._error('malformed if: ' + reduce(add, ls, ''))
     499                    self._error('invalid %if operator: ' + functools.reduce(add, ls, ''))
     500            else:
     501                self._error('malformed if: ' + functools.reduce(add, ls, ''))
    493502            if invert:
    494503                istrue = not istrue
     
    751760            log.trace('config: %s: _open: %s' % (self.init_name, path.host(configname)))
    752761            config = open(path.host(configname), 'r')
    753         except IOError, err:
     762        except IOError as err:
    754763            raise error.general('error opening config file: %s' % (path.host(configname)))
    755764        self.configpath += [configname]
     
    837846        # Run where defaults.mc is located
    838847        #
    839         opts = options.load(sys.argv, defaults = 'defaults.mc')
    840         log.trace('config: count %d' % (len(opts.config_files())))
    841         for config_file in opts.config_files():
    842             s = file(config_file, opts)
    843             print s
    844             del s
    845     except error.general, gerr:
    846         print gerr
     848        long_opts = {
     849            # key              macro        handler   param  defs   init
     850            '--file'  :      ('_file',      'path',   True,  None,  False)
     851        }
     852        opts = options.command_line(base_path = '.',
     853                                    argv = sys.argv,
     854                                    long_opts = long_opts)
     855        options.load(opts)
     856        s = file(opts.defaults['_file'], opts)
     857        s.load(opts.defaults['_file'])
     858        print(s)
     859        del s
     860    except error.general as gerr:
     861        print(gerr)
    847862        sys.exit(1)
    848     except error.internal, ierr:
    849         print ierr
     863    except error.internal as ierr:
     864        print(ierr)
    850865        sys.exit(1)
    851866    except KeyboardInterrupt:
  • rtemstoolkit/darwin.py

    ra4c070c r4001a74  
    3636import os
    3737
    38 import execute
     38try:
     39    from . import execute
     40except (ValueError, SystemError):
     41    import execute
    3942
    4043def load():
  • rtemstoolkit/error.py

    ra4c070c r4001a74  
    3333#
    3434
     35from __future__ import print_function
     36
    3537class error(Exception):
    3638    """Base class for Builder exceptions."""
     
    5860    try:
    5961        raise general('a general error')
    60     except general, gerr:
    61         print 'caught:', gerr
     62    except general as gerr:
     63        print('caught:', gerr)
    6264    try:
    6365        raise internal('an internal error')
    64     except internal, ierr:
    65         print 'caught:', ierr
     66    except internal as ierr:
     67        print('caught:', ierr)
  • rtemstoolkit/execute.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2010-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2010-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3535#
    3636
     37from __future__ import print_function
     38
     39import functools
    3740import os
    3841import re
     
    4245import time
    4346
    44 import error
    45 import log
     47#
     48# Support to handle use in a package and as a unit test.
     49# If there is a better way to let us know.
     50#
     51try:
     52    from . import error
     53    from . import log
     54except (ValueError, SystemError):
     55    import error
     56    import log
    4657
    4758# Trace exceptions
     
    97108    cmd = arg_subst(command, subst)
    98109    def add(x, y): return x + ' ' + str(y)
    99     return reduce(add, cmd, '')
     110    return functools.reduce(add, cmd, '')
    100111
    101112class execute(object):
     
    119130        self.proc = None
    120131
    121     def _capture(self, command, proc, timeout = None):
     132    def capture(self, proc, command = 'pipe', timeout = None):
    122133        """Create 3 threads to read stdout and stderr and send to the output handler
    123134        and call an input handler is provided. Based on the 'communicate' code
     
    128139            is a timeout check."""
    129140            if trace_threads:
    130                 print 'executte:_writethread: start'
     141                print('executte:_writethread: start')
    131142            try:
    132143                while True:
    133                     lines = input()
     144                    lines = eval(input())
    134145                    if type(lines) == str:
    135146                        try:
    136                             fh.write(lines)
     147                            fh.write(bytes(lines, sys.stdin.encoding))
    137148                        except:
    138149                            break
     
    143154            except:
    144155                if trace_threads:
    145                     print 'executte:_writethread: exception'
     156                    print('executte:_writethread: exception')
    146157                pass
    147158            try:
     
    150161                pass
    151162            if trace_threads:
    152                 print 'executte:_writethread: finished'
     163                print('executte:_writethread: finished')
    153164
    154165        def _readthread(exe, fh, out, prefix = ''):
     
    156167            until the file closes."""
    157168            def _output_line(line, exe, prefix, out, count):
    158                 #print 'LINE:%d: %s' % (count, line)
    159                 exe.lock.acquire()
     169                #exe.lock.acquire()
    160170                #exe.outputting = True
    161                 exe.lock.release()
     171                #exe.lock.release()
    162172                if out:
    163173                    out(prefix + line)
     
    168178
    169179            if trace_threads:
    170                 print 'executte:_readthread: start'
     180                print('executte:_readthread: start')
    171181            count = 0
    172182            line = ''
     
    176186                    if len(data) == 0:
    177187                        break
    178                     #print '))))) %02x "%s"' % (ord(data), data)
     188                    if type(data) == bytes:
     189                        data = data.decode(sys.stdout.encoding)
    179190                    for c in data:
    180191                        line += c
     
    188199                raise
    189200                if trace_threads:
    190                     print 'executte:_readthread: exception'
     201                    print('executte:_readthread: exception')
    191202                pass
    192203            try:
     
    197208                _output_line(line, exe, prefix, out, 100)
    198209            if trace_threads:
    199                 print 'executte:_readthread: finished'
     210                print('executte:_readthread: finished')
    200211
    201212        def _timerthread(exe, interval, function):
     
    306317            if type(command) is list:
    307318                def add(x, y): return x + ' ' + str(y)
    308                 s = reduce(add, command, '')[1:]
     319                s = functools.reduce(add, command, '')[1:]
    309320            what = 'spawn'
    310321            if shell:
    311322                what = 'shell'
    312323            log.output(what + ': ' + s)
     324        if self.output is None:
     325            raise error.general('capture needs an output handler')
    313326        if shell and self.shell_exe:
    314327            command = arg_list(command)
     
    341354            if not capture:
    342355                return (0, proc)
    343             if self.output is None:
    344                 raise error.general('capture needs an output handler')
    345             exit_code = self._capture(command, proc, timeout)
     356            exit_code = self.capture(proc, command, timeout)
    346357            if self.verbose:
    347358                log.output('exit: ' + str(exit_code))
    348         except OSError, ose:
     359        except OSError as ose:
    349360            exit_code = ose.errno
    350361            if self.verbose:
     
    396407                            cwd = cwd, env = env,
    397408                            stdin = stdin, stdout = stdout, stderr = stderr,
    398                             itmeout = timeout)
     409                            timeout = timeout)
    399410
    400411    def set_shell(self, execute):
     
    454465        try:
    455466            if self.proc is not None:
    456                 print "sending sig"
     467                print("sending sig")
    457468                self.proc.send_signal(signal)
    458469        except:
     
    503514
    504515if __name__ == "__main__":
     516
    505517    def run_tests(e, commands, use_shell):
    506518        for c in commands['shell']:
     
    518530                             capture = False, stdin = subprocess.PIPE)
    519531        if ec == 0:
    520             print 'piping input into ' + commands['pipe'][0] + ': ' + \
    521                   commands['pipe'][2]
    522             proc.stdin.write(commands['pipe'][2])
     532            print('piping input into ' + commands['pipe'][0] + ': ' + \
     533                  commands['pipe'][2])
     534            try:
     535                out = bytes(commands['pipe'][2], sys.stdin.encoding)
     536            except:
     537                out = bytes(commands['pipe'][2])
     538            proc.stdin.write(out)
    523539            proc.stdin.close()
    524540            e.capture(proc)
    525541            del proc
     542
     543    def capture_output(text):
     544        print(text, end = '')
    526545
    527546    cmd_shell_test = 'if "%OS%" == "Windows_NT" (echo It is WinNT) else echo Is is not WinNT'
     
    545564    commands['unix']['pipe'] = ('grep', 'hello', 'hello world')
    546565
    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'])
    551 
    552     e = execute(error_prefix = 'ERR: ', verbose = True)
     566    print(arg_list('cmd a1 a2 "a3 is a string" a4'))
     567    print(arg_list('cmd b1 b2 "b3 is a string a4'))
     568    print(arg_subst(['nothing', 'xx-%0-yyy', '%1', '%2-something'],
     569                    ['subst0', 'subst1', 'subst2']))
     570
     571    e = execute(error_prefix = 'ERR: ', output = capture_output, verbose = True)
    553572    if sys.platform == "win32":
    554573        run_tests(e, commands['windows'], False)
  • rtemstoolkit/freebsd.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2010-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2010-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3737import os
    3838
    39 import check
    40 import execute
     39#
     40# Support to handle use in a package and as a unit test.
     41# If there is a better way to let us know.
     42#
     43try:
     44    from . import check
     45    from . import execute
     46except (ValueError, SystemError):
     47    import check
     48    import execute
    4149
    4250def load():
  • rtemstoolkit/git.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2010-2015 Chris Johns (chrisj@rtems.org)
     3# Copyright 2010-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3030#
    3131
     32from __future__ import print_function
     33
    3234import os
    3335
    34 import error
    35 import execute
    36 import log
    37 import options
    38 import path
     36#
     37# Support to handle use in a package and as a unit test.
     38# If there is a better way to let us know.
     39#
     40try:
     41    from . import error
     42    from . import execute
     43    from . import log
     44    from . import path
     45except (ValueError, SystemError):
     46    import error
     47    import execute
     48    import log
     49    import path
    3950
    4051class repo:
    4152    """An object to manage a git repo."""
    4253
    43     def _git_exit_code(self, ec):
     54    def _git_exit_code(self, ec, cmd, output):
    4455        if ec:
     56            print(output)
    4557            raise error.general('git command failed (%s): %d' % (self.git, ec))
    4658
     
    5668        log.trace(output)
    5769        if check:
    58             self._git_exit_code(exit_code)
     70            self._git_exit_code(exit_code, cmd, output)
    5971        return exit_code, output
    6072
     
    7789            raise error.general('invalid version string from git: %s' % (output))
    7890        vs = gvs[2].split('.')
    79         if len(vs) != 4:
    80             raise error.general('invalid version number from git: %s' % (gvs[2]))
    81         return (int(vs[0]), int(vs[1]), int(vs[2]), int(vs[3]))
     91        if len(vs) == 4:
     92            return (int(vs[0]), int(vs[1]), int(vs[2]), int(vs[3]))
     93        if len(vs) == 3:
     94            return (int(vs[0]), int(vs[1]), int(vs[2]))
     95        raise error.general('invalid version number from git: %s' % (gvs[2]))
    8296
    8397    def clone(self, url, _path):
     
    208222if __name__ == '__main__':
    209223    import sys
    210     opts = options.load(sys.argv)
     224    import options
     225    long_opts = {
     226        # key              macro        handler   param  defs   init
     227    }
     228    opts = options.command_line(base_path = '.',
     229                                argv = sys.argv,
     230                                long_opts = long_opts)
     231    options.load(opts)
    211232    g = repo('.', opts)
    212     print g.git_version()
    213     print g.valid()
    214     print g.status()
    215     print g.clean()
    216     print g.remotes()
    217     print g.email()
    218     print g.head()
     233    print('version:', g.git_version())
     234    print('valid:', g.valid())
     235    print('status:', g.status())
     236    print('dirty:', g.dirty())
     237    print('remotes:', g.remotes())
     238    print('email:', g.email())
     239    print('head:', g.head())
  • rtemstoolkit/linux.py

    ra4c070c r4001a74  
    3636import pprint
    3737import os
     38import platform
    3839
    39 import platform
    40 import execute
    41 import path
     40#
     41# Support to handle use in a package and as a unit test.
     42# If there is a better way to let us know.
     43#
     44try:
     45    from . import execute
     46    from . import path
     47except (ValueError, SystemError):
     48    import execute
     49    import path
    4250
    4351def load():
     
    131139        }
    132140
    133     if variations.has_key(distro):
     141    if variations in distro:
    134142        for v in variations[distro]:
    135143            if path.exists(variations[distro][v][2]):
  • rtemstoolkit/log.py

    ra4c070c r4001a74  
    3333#
    3434
     35from __future__ import print_function
     36
    3537import os
    3638import sys
    3739import threading
    3840
    39 import error
     41#
     42# Support to handle use in a package and as a unit test.
     43# If there is a better way to let us know.
     44#
     45try:
     46    from . import error
     47except (ValueError, SystemError):
     48    import error
    4049
    4150#
     
    7584        lock.acquire()
    7685        for l in text.replace(chr(13), '').splitlines():
    77             print l
     86            print(l)
    7887        lock.release()
    7988
     
    8190    lock.acquire()
    8291    for l in text.replace(chr(13), '').splitlines():
    83         print >> sys.stderr, l
     92        print(l, file = sys.stderr)
    8493    lock.release()
    8594
     
    93102        lock.acquire()
    94103        for l in text.replace(chr(13), '').splitlines():
    95             print l
     104            print(l)
    96105        lock.release()
    97106    if not stdout_only:
     
    127136                else:
    128137                    try:
    129                         self.fhs.append(file(s, 'w'))
    130                     except IOError, ioe:
     138                        self.fhs.append(open(s, 'w'))
     139                    except IOError as ioe:
    131140                         raise error.general("creating log file '" + s + \
    132141                                             "': " + str(ioe))
     
    187196    l.output('log: hello world NONE')
    188197    l.flush()
    189     print '=-' * 40
    190     print 'tail: %d' % (len(l.tail))
    191     print l
    192     print '=-' * 40
     198    print('=-' * 40)
     199    print('tail: %d' % (len(l.tail)))
     200    print(l)
     201    print('=-' * 40)
    193202    for i in range(0, 10):
    194203        l.output('log: hello world 2: %d\n' % (i))
    195204    l.flush()
    196     print '=-' * 40
    197     print 'tail: %d' % (len(l.tail))
    198     print l
    199     print '=-' * 40
     205    print('=-' * 40)
     206    print('tail: %d' % (len(l.tail)))
     207    print(l)
     208    print('=-' * 40)
    200209    for i in [0, 1]:
    201210        quiet = False
    202211        tracing = False
    203         print '- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30)
     212        print('- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30))
    204213        trace('trace with quiet and trace off')
    205214        notice('notice with quiet and trace off')
    206215        quiet = True
    207216        tracing = False
    208         print '- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30)
     217        print('- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30))
    209218        trace('trace with quiet on and trace off')
    210219        notice('notice with quiet on and trace off')
    211220        quiet = False
    212221        tracing = True
    213         print '- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30)
     222        print('- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30))
    214223        trace('trace with quiet off and trace on')
    215224        notice('notice with quiet off and trace on')
    216225        quiet = True
    217226        tracing = True
    218         print '- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30)
     227        print('- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30))
    219228        trace('trace with quiet on and trace on')
    220229        notice('notice with quiet on and trace on')
    221230        default = l
    222     print '=-' * 40
    223     print 'tail: %d' % (len(l.tail))
    224     print l
    225     print '=-' * 40
     231    print('=-' * 40)
     232    print('tail: %d' % (len(l.tail)))
     233    print(l)
     234    print('=-' * 40)
    226235    del l
  • rtemstoolkit/macros.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2010-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2010-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3333#
    3434
     35from __future__ import print_function
     36
    3537import copy
    3638import inspect
     
    3941import string
    4042
    41 import error
    42 import path
     43#
     44# Support to handle use in a package and as a unit test.
     45# If there is a better way to let us know.
     46#
     47try:
     48    from . import error
     49    from . import path
     50except (ValueError, SystemError):
     51    import error
     52    import path
    4353
    4454#
     
    5565            return self
    5666
    57         def next(self):
     67        def __next__(self):
    5868            if self.index < len(self.keys):
    5969                key = self.keys[self.index]
     
    6474        def iterkeys(self):
    6575            return self.keys
     76
     77    def _unicode_to_str(self, us):
     78        try:
     79            if type(us) == unicode:
     80                return us.encode('ascii', 'replace')
     81        except:
     82            pass
     83        try:
     84            if type(us) == bytes:
     85                return us.encode('ascii', 'replace')
     86        except:
     87            pass
     88        return us
    6689
    6790    def __init__(self, name = None, original = None, rtdir = '.'):
     
    157180
    158181    def __iter__(self):
    159         return macros.macro_iterator(self.keys())
     182        return macros.macro_iterator(list(self.keys()))
    160183
    161184    def __getitem__(self, key):
     
    168191        if type(key) is not str:
    169192            raise TypeError('bad key type (want str): %s' % (type(key)))
     193        if type(value) is not tuple:
     194            value = self._unicode_to_str(value)
    170195        if type(value) is str:
    171196            value = ('none', 'none', value)
     
    174199        if len(value) != 3:
    175200            raise TypeError('bad value tuple (len not 3): %d' % (len(value)))
     201        value = (self._unicode_to_str(value[0]),
     202                 self._unicode_to_str(value[1]),
     203                 self._unicode_to_str(value[2]))
    176204        if type(value[0]) is not str:
    177205            raise TypeError('bad value tuple type field: %s' % (type(value[0])))
     
    196224
    197225    def __len__(self):
    198         return len(self.keys())
     226        return len(list(self.keys()))
    199227
    200228    def keys(self):
    201         keys = self.macros['global'].keys()
     229        keys = list(self.macros['global'].keys())
    202230        for rm in self.get_read_maps():
    203231            for mk in self.macros[rm]:
     
    212240        if type(key) is not str:
    213241            raise TypeError('bad key type (want str): %s' % (type(key)))
    214         if self.key_filter(key) not in self.keys():
     242        if self.key_filter(key) not in list(self.keys()):
    215243            return False
    216244        return True
    217245
    218246    def maps(self):
    219         return self.macros.keys()
     247        return list(self.macros.keys())
    220248
    221249    def get_read_maps(self):
     
    240268        trace_me = False
    241269        if trace_me:
    242             print '[[[[]]]] parsing macros'
     270            print('[[[[]]]] parsing macros')
    243271        orig_macros = copy.copy(self.macros)
    244272        map = 'global'
     
    255283            for c in l:
    256284                if trace_me:
    257                     print ']]]]]]]] c:%s(%d) s:%s t:"%s" m:%r M:%s' % \
    258                         (c, ord(c), state, token, macro, map)
     285                    print(']]]]]]]] c:%s(%d) s:%s t:"%s" m:%r M:%s' % \
     286                        (c, ord(c), state, token, macro, map))
    259287                l_remaining = l_remaining[1:]
    260288                if c is '#' and not state.startswith('value'):
     
    379407                    self.files += [n]
    380408                    return
    381                 except IOError, err:
     409                except IOError as err:
    382410                    pass
    383411        raise error.general('opening macro file: %s' % \
     
    453481        what = re.compile(regex)
    454482        keys = []
    455         for key in self.keys():
     483        for key in list(self.keys()):
    456484            if what.match(key):
    457485                keys += [key]
     
    491519    import copy
    492520    import sys
    493     print inspect.getfile(macros)
    494     m = macros(name = 'defaults.mc')
     521    print(inspect.getfile(macros))
     522    m = macros()
    495523    d = copy.copy(m)
    496524    m['test1'] = 'something'
    497     if d.has_key('test1'):
    498         print 'error: copy failed.'
     525    if 'test1' in d:
     526        print('error: copy failed.')
    499527        sys.exit(1)
    500528    m.parse("[test]\n" \
    501529            "test1: none, undefine, ''\n" \
    502530            "name:  none, override, 'pink'\n")
    503     print 'set test:', m.set_read_map('test')
     531    print('set test:', m.set_read_map('test'))
    504532    if m['name'] != 'pink':
    505         print 'error: override failed. name is %s' % (m['name'])
     533        print('error: override failed. name is %s' % (m['name']))
    506534        sys.exit(1)
    507     if m.has_key('test1'):
    508         print 'error: map undefine failed.'
     535    if 'test1' in m:
     536        print('error: map undefine failed.')
    509537        sys.exit(1)
    510     print 'unset test:', m.unset_read_map('test')
    511     print m
    512     print m.keys()
     538    print('unset test:', m.unset_read_map('test'))
     539    print(m)
     540    print(list(m.keys()))
  • rtemstoolkit/mailer.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2013-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2013-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3333#
    3434
     35from __future__ import print_function
     36
    3537import os
    3638import smtplib
    3739import socket
    3840
    39 import error
    40 import options
    41 import path
     41#
     42# Support to handle use in a package and as a unit test.
     43# If there is a better way to let us know.
     44#
     45try:
     46    from . import error
     47    from . import options
     48    from . import path
     49except (ValueError, SystemError):
     50    import error
     51    import options
     52    import path
    4253
    4354def append_options(opts):
     
    7687                lines = mrc.readlines()
    7788                mrc.close()
    78             except IOError, err:
     89            except IOError as err:
    7990                raise error.general('error reading: %s' % (mailrc))
    8091            for l in lines:
     
    105116            s = smtplib.SMTP(self.smtp_host())
    106117            s.sendmail(from_addr, [to_addr], msg)
    107         except smtplib.SMTPException, se:
     118        except smtplib.SMTPException as se:
    108119            raise error.general('sending mail: %s' % (str(se)))
    109         except socket.error, se:
     120        except socket.error as se:
    110121            raise error.general('sending mail: %s' % (str(se)))
    111122
     
    114125    optargs = {}
    115126    append_options(optargs)
    116     opts = options.load(sys.argv, optargs = optargs, defaults = 'defaults.mc')
     127    opts = options.load(sys.argv)
    117128    m = mail(opts)
    118     print 'From: %s' % (m.from_address())
    119     print 'SMTP Host: %s' % (m.smtp_host())
     129    print('From: %s' % (m.from_address()))
     130    print('SMTP Host: %s' % (m.smtp_host()))
    120131    m.send(m.from_address(), 'Test mailer.py', 'This is a test')
  • rtemstoolkit/options.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2010-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2010-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3333#
    3434
     35from __future__ import print_function
     36
    3537import copy
    3638import glob
     
    3941import os
    4042import string
    41 
    42 import error
    43 import execute
    44 import git
    45 import log
    46 import macros
    47 import path
    4843import sys
    4944
    50 import version
     45#
     46# Support to handle use in a package and as a unit test.
     47# If there is a better way to let us know.
     48#
     49try:
     50    from . import error
     51    from . import execute
     52    from . import git
     53    from . import log
     54    from . import macros
     55    from . import path
     56    from . import version
     57except (ValueError, SystemError):
     58    import error
     59    import execute
     60    import git
     61    import log
     62    import macros
     63    import path
     64    import version
    5165
    5266basepath = 'tb'
     
    6276    def __init__(self, base_path = None, argv = None, optargs = None,
    6377                 defaults = None, long_opts = None, long_opts_help = None,
    64                  command_path = None, log_default = None):
     78                 command_path = '', log_default = None):
    6579
    6680        if argv is None:
     
    7791            raise error.general('log default is a list')
    7892        self.log_default = log_default
     93
     94        if defaults is None:
     95            defaults = macros.macros()
    7996
    8097        self.long_opts = {
     
    129146                handler = self._lo_string
    130147            elif long_opts[lo][1] == 'path':
    131                 hanlder = self._lo_path
     148                handler = self._lo_path
    132149            elif long_opts[lo][1] == 'jobs':
    133150                handler = self._lo_jobs
     
    140157            self.long_opts[lo] = (long_opts[lo][0], handler, long_opts[lo][2],
    141158                                   long_opts[lo][3], long_opts[lo][4])
    142             if lo not in long_opts_help:
    143                 raise error.general('no help for option: %s' % (lo))
    144             self.long_opts_help[lo] = long_opts_help[lo]
     159            if long_opts_help is not None:
     160                if lo not in long_opts_help:
     161                    raise error.general('no help for option: %s' % (lo))
     162                self.long_opts_help[lo] = long_opts_help[lo]
    145163
    146164    def __copy__(self):
     
    160178        def _dict(dd):
    161179            s = ''
    162             ddl = dd.keys()
     180            ddl = list(dd.keys())
    163181            ddl.sort()
    164182            for d in ddl:
     
    274292
    275293    def help(self):
    276         print '%s: [options] [args]' % (self.command_name)
    277         print 'RTEMS Tools Project (c) 2012-2014 Chris Johns'
    278         print 'Options and arguments:'
    279         opts = self.long_opts_help.keys()
     294        print('%s: [options] [args]' % (self.command_name))
     295        print('RTEMS Tools Project (c) 2012-2014 Chris Johns')
     296        print('Options and arguments:')
     297        opts = list(self.long_opts_help.keys())
    280298        if self.optargs:
    281             opts += self.optargs.keys()
     299            opts += list(self.optargs.keys())
    282300        indent = self._help_indent()
    283301        for o in sorted(opts):
     
    288306            else:
    289307                raise error.general('invalid help data: %s' %(o))
    290             print '%-*s : %s' % (indent, o, h)
     308            print('%-*s : %s' % (indent, o, h))
    291309        raise error.exit()
    292310
     
    519537    """
    520538
     539    if not isinstance(opts, command_line):
     540        raise error.general('invalid opt type')
     541
    521542    global host_windows
    522543
     
    533554        try:
    534555            if uname[0].startswith('CYGWIN_NT'):
    535                 import windows
     556                try:
     557                    from . import windows
     558                except:
     559                    import windows
    536560                overrides = windows.load()
    537561            elif uname[0] == 'Darwin':
    538                 import darwin
     562                try:
     563                    from . import darwin
     564                except:
     565                    import darwin
    539566                overrides = darwin.load()
    540567            elif uname[0] == 'FreeBSD':
    541                 import freebsd
     568                try:
     569                    from . import freebsd
     570                except:
     571                    import freebsd
    542572                overrides = freebsd.load()
    543573            elif uname[0] == 'NetBSD':
    544                 import netbsd
     574                try:
     575                    from . import netbsd
     576                except:
     577                    import netbsd
    545578                overrides = netbsd.load()
    546579            elif uname[0] == 'Linux':
    547                 import linux
    548                 overrides = linux.load()
     580                try:
     581                    from . import linux
     582                except:
     583                    import linux
     584            elif uname[0] == 'SunOS':
     585                try:
     586                    from . import solaris
     587                except:
     588                    import solaris
     589                overrides = solaris.load()
    549590        except:
    550591            raise error.general('failed to load %s host support' % (uname[0]))
     
    581622        log.notice('Defaults:')
    582623        log.notice(str(opts.defaults))
    583     except error.general, gerr:
    584         print gerr
     624    except error.general as gerr:
     625        print(gerr)
    585626        sys.exit(1)
    586     except error.internal, ierr:
    587         print ierr
     627    except error.internal as ierr:
     628        print(ierr)
    588629        sys.exit(1)
    589     except error.exit, eerr:
     630    except error.exit as eerr:
    590631        pass
    591632    except KeyboardInterrupt:
  • rtemstoolkit/path.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2010-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2010-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3535#
    3636
     37from __future__ import print_function
     38
    3739import glob
    38 import log
    3940import os
    4041import shutil
    4142import string
    4243
    43 import error
     44#
     45# Support to handle use in a package and as a unit test.
     46# If there is a better way to let us know.
     47#
     48try:
     49    from . import error
     50    from . import log
     51except (ValueError, SystemError):
     52    import error
     53    import log
    4454
    4555windows = os.name == 'nt'
     
    123133            try:
    124134                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:
     135            except IOError as err:
     136                raise error.general('cannot make directory: %s' % (path))
     137            except OSError as err:
     138                raise error.general('cannot make directory: %s' % (path))
     139            except WindowsError as err:
    130140                raise error.general('cannot make directory: %s' % (path))
    131141        else:
    132142            try:
    133143                os.makedirs(host(path))
    134             except IOError, err:
    135                 raise error.general('cannot make directory: %s' % (path))
    136             except OSError, err:
     144            except IOError as err:
     145                raise error.general('cannot make directory: %s' % (path))
     146            except OSError as err:
    137147                raise error.general('cannot make directory: %s' % (path))
    138148
     
    140150
    141151    def _onerror(function, path, excinfo):
    142         print 'removeall error: (%s) %s' % (excinfo, path)
     152        print('removeall error: (%s) %s' % (excinfo, path))
    143153
    144154    path = host(path)
     
    209219            else:
    210220                shutil.copy2(srcname, dstname)
    211         except shutil.Error, err:
     221        except shutil.Error as err:
    212222            raise error.general('copying tree: %s -> %s: %s' % (src, dst, str(err)))
    213         except EnvironmentError, why:
     223        except EnvironmentError as why:
    214224            raise error.general('copying tree: %s -> %s: %s' % (srcname, dstname, str(why)))
    215225    try:
    216226        shutil.copystat(src, dst)
    217     except OSError, why:
     227    except OSError as why:
    218228        ok = False
    219229        if windows:
     
    224234
    225235if __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')
     236    print(host('/a/b/c/d-e-f'))
     237    print(host('//a/b//c/d-e-f'))
     238    print(shell('/w/x/y/z'))
     239    print(basename('/as/sd/df/fg/me.txt'))
     240    print(dirname('/as/sd/df/fg/me.txt'))
     241    print(join('/d', 'g', '/tyty/fgfg'))
    232242    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')
     243    print(host('/a/b/c/d-e-f'))
     244    print(host('//a/b//c/d-e-f'))
     245    print(shell('/w/x/y/z'))
     246    print(shell('w:/x/y/z'))
     247    print(basename('x:/sd/df/fg/me.txt'))
     248    print(dirname('x:/sd/df/fg/me.txt'))
     249    print(join('s:/d/', '/g', '/tyty/fgfg'))
  • rtemstoolkit/stacktraces.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2013-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2013-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3434def trace():
    3535    code = []
    36     for threadId, stack in sys._current_frames().items():
     36    for threadId, stack in list(sys._current_frames().items()):
    3737        code.append("\n# thread-id: %s" % threadId)
    3838        for filename, lineno, name, line in traceback.extract_stack(stack):
     
    4141                code.append("  %s" % (line.strip()))
    4242    return '\n'.join(code)
    43 
  • rtemstoolkit/version.py

    ra4c070c r4001a74  
    3434#
    3535
     36from __future__ import print_function
     37
    3638import sys
    3739
    38 import error
    39 import git
    40 import path
     40#
     41# Support to handle use in a package and as a unit test.
     42# If there is a better way to let us know.
     43#
     44try:
     45    from . import error
     46    from . import git
     47    from . import path
     48except (ValueError, SystemError):
     49    import error
     50    import git
     51    import path
    4152
    4253#
     
    95106
    96107if __name__ == '__main__':
    97     print 'Version: %s' % (str())
     108    print('Version: %s' % (str()))
  • rtemstoolkit/windows.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2010-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2010-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3333#
    3434
    35 import error
    3635import pprint
    3736import os
    3837
    39 import execute
     38#
     39# Support to handle use in a package and as a unit test.
     40# If there is a better way to let us know.
     41#
     42try:
     43    from . import error
     44    from . import execute
     45except (ValueError, SystemError):
     46    import error
     47    import execute
    4048
    4149def load():
     
    4351    uname = 'win32'
    4452    system = 'mingw32'
    45     if os.environ.has_key('HOSTTYPE'):
     53    if 'HOSTTYPE' in os.environ:
    4654        hosttype = os.environ['HOSTTYPE']
    4755    else:
     
    6977            pass
    7078
    71     if os.environ.has_key('NUMBER_OF_PROCESSORS'):
     79    if 'NUMBER_OF_PROCESSORS' in os.environ:
    7280        ncpus = os.environ['NUMBER_OF_PROCESSORS']
    7381    else:
  • tester/rt/config.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2013-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2013-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3333#
    3434
     35from __future__ import print_function
     36
    3537import datetime
    3638import os
     
    4345from rtemstoolkit import path
    4446
    45 import console
    46 import gdb
     47from . import console
     48from . import gdb
    4749
    4850timeout = 15
     
    186188        if self.realtime_trace:
    187189            for l in text:
    188                 print ' '.join(l)
     190                print(' '.join(l))
    189191
    190192    def run(self):
  • tester/rt/console.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2013-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2013-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3333#
    3434
     35from __future__ import print_function
     36
    3537import errno
    3638import fcntl
     
    3941import time
    4042
    41 import stty
     43from . import stty
    4244
    4345def save():
     
    9193        super(tty, self).__del__()
    9294        if self._tracing():
    93             print ':: tty close', self.dev
     95            print(':: tty close', self.dev)
    9496        fcntl.fcntl(me.tty.fd, fcntl.F_SETFL,
    9597                    fcntl.fcntl(me.tty.fd, fcntl.F_GETFL) & ~os.O_NONBLOCK)
     
    99101        def _readthread(me, x):
    100102            if self._tracing():
    101                 print ':: tty runner started', self.dev
     103                print(':: tty runner started', self.dev)
    102104            fcntl.fcntl(me.tty.fd, fcntl.F_SETFL,
    103105                        fcntl.fcntl(me.tty.fd, fcntl.F_GETFL) | os.O_NONBLOCK)
     
    107109                try:
    108110                    data = me.tty.fd.read()
    109                 except IOError, ioe:
     111                except IOError as ioe:
    110112                    if ioe.errno == errno.EAGAIN:
    111113                        continue
     
    122124                        line = ''
    123125            if self._tracing():
    124                 print ':: tty runner finished', self.dev
     126                print(':: tty runner finished', self.dev)
    125127        if self._tracing():
    126             print ':: tty open', self.dev
     128            print(':: tty open', self.dev)
    127129        self.tty = stty.tty(self.dev)
    128130        self.tty.set(self.setup)
  • tester/rt/gdb.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2013-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2013-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3333#
    3434
     35from __future__ import print_function
     36
    3537import os
    36 import Queue
    3738import sys
    3839import termios
    3940import threading
     41
     42try:
     43    import queue
     44except ImportError:
     45    import Queue
     46    queue = Queue
    4047
    4148from rtemstoolkit import error
     
    4451from rtemstoolkit import path
    4552
    46 import console
    47 import pygdb
     53from . import console
     54from . import pygdb
    4855
    4956#
     
    6673        self.output = None
    6774        self.gdb_console = None
    68         self.input = Queue.Queue()
    69         self.commands = Queue.Queue()
     75        self.input = queue.Queue()
     76        self.commands = queue.Queue()
    7077        self.process = None
    7178        self.state = {}
     
    7885    def _lock(self, msg):
    7986        if self.lock_trace:
    80             print '|[   LOCK:%s ]|' % (msg)
     87            print('|[   LOCK:%s ]|' % (msg))
    8188        self.lock.acquire()
    8289
    8390    def _unlock(self, msg):
    8491        if self.lock_trace:
    85             print '|] UNLOCK:%s [|' % (msg)
     92            print('|] UNLOCK:%s [|' % (msg))
    8693        self.lock.release()
    8794
     
    94101    def _put(self, text):
    95102        if self.trace:
    96             print ')))', text
     103            print(')))', text)
    97104        self.commands.put(text)
    98105
     
    102109        try:
    103110            if self.trace:
    104                 print '... input empty ', self.input.empty()
     111                print('... input empty ', self.input.empty())
    105112            if self.input.empty():
    106113                line = self.commands.get(block = False)
    107114                if self.trace:
    108                     print '+++', line
     115                    print('+++', line)
    109116                self.input.put(line)
    110117        except:
     
    115122        self._lock('_reader')
    116123        if self.trace:
    117             print '<<<', line
     124            print('<<<', line)
    118125        try:
    119126            self.lc += 1
    120127            if line.startswith('(gdb)'):
    121128                if self.trace:
    122                     print '^^^ (gdb)'
     129                    print('^^^ (gdb)')
    123130                if not self._input_commands():
    124131                    self.gdb_expect()
     
    140147                line = self.input.get(timeout = 0.5)
    141148                if self.trace:
    142                     print '>>> input: queue=%d' % (self.input.qsize()), line
    143             except Queue.Empty:
     149                    print('>>> input: queue=%d' % (self.input.qsize()), line)
     150            except queue.Empty:
    144151                return True
    145152            if line is None:
     
    148155        except:
    149156            if self.trace:
    150                 print 'writer exception'
     157                print('writer exception')
    151158            pass
    152159        if self.trace:
    153             print 'writer closing'
     160            print('writer closing')
    154161        return False
    155162
     
    208215            ec, proc = self.process.open(cmds, timeout = (timeout, self._timeout))
    209216            if self.trace:
    210                 print 'gdb done', ec
     217                print('gdb done', ec)
    211218            if ec > 0:
    212219                raise error.general('gdb exec: %s: %s' % (cmds[0], os.strerror(ec)))
     
    221228    def gdb_expect(self):
    222229        if self.trace:
    223             print '}}} gdb-expect'
     230            print('}}} gdb-expect')
    224231        if self.process and not self.running and self.script is not None:
    225232            if self.script_line == len(self.script):
     
    240247            try:
    241248                if self.mi_trace:
    242                     print 'mi-data:', lines
     249                    print('mi-data:', lines)
    243250                rec = pygdb.mi_parser.process(lines)
    244251            finally:
    245252                self._mi_unlock()
    246253            if self.mi_trace:
    247                 print 'mi-rec:', rec
     254                print('mi-rec:', rec)
    248255            if rec.record_type == 'result':
    249256                if rec.type == 'result':
     
    257264                    if rec.class_ == 'running':
    258265                        if self.trace:
    259                             print '*** running'
     266                            print('*** running')
    260267                        self._put('')
    261268                        self.running = True
    262269                    elif rec.class_ == 'stopped':
    263270                        if self.trace:
    264                             print '*** stopped'
     271                            print('*** stopped')
    265272                        self.running = False
    266273                        #self._put('-data-list-register-values')
     
    285292                        lines = self.output_buffer[:last_lf]
    286293                        if self.trace:
    287                             print '/// console output'
     294                            print('/// console output')
    288295                        for line in lines.splitlines():
    289296                            self.output(line)
     
    291298        except:
    292299            if self.trace:
    293                 print '/// console output'
     300                print('/// console output')
    294301            for line in lines.splitlines():
    295302                self.output(line)
     
    299306    try:
    300307        def output(text):
    301             print ']', text
     308            print(']', text)
    302309        def gdb_console(text):
    303             print '>', text
     310            print('>', text)
    304311        script = ['target sim']
    305312        if len(sys.argv) > 1:
  • tester/rt/options.py

    ra4c070c r4001a74  
    3333#
    3434
     35from __future__ import print_function
     36
    3537import glob
    3638import pprint
     
    4648from rtemstoolkit import options
    4749from rtemstoolkit import path
    48 
    49 import version
     50from rtemstoolkit import version
    5051
    5152#
     
    115116        log.notice('Defaults:')
    116117        log.notice(str(_opts.defaults))
    117     except error.general, gerr:
    118         print gerr
     118    except error.general as gerr:
     119        print(gerr)
    119120        sys.exit(1)
    120     except error.internal, ierr:
    121         print ierr
     121    except error.internal as ierr:
     122        print(ierr)
    122123        sys.exit(1)
    123     except error.exit, eerr:
     124    except error.exit as eerr:
    124125        pass
    125126    except KeyboardInterrupt:
  • tester/rt/pygdb/__init__.py

    ra4c070c r4001a74  
    1818
    1919all = ['mi_parser']
    20 from mi_parser import scan
    21 from mi_parser import process
     20from . import mi_parser
     21scan = mi_parser.scan
     22process = mi_parser.process
  • tester/rt/pygdb/mi_parser.py

    ra4c070c r4001a74  
    2929# $Id$
    3030
     31from __future__ import print_function
    3132
    3233import re
    3334import pprint
    34 import spark
     35
     36from . import spark
    3537
    3638def __private():
     
    9496                def t_default(self, s):
    9597                        r'( . | \n )+'
    96                         raise Exception, "Specification error: unmatched input for '%s'" % s
     98                        raise Exception("Specification error: unmatched input for '%s'" % s)
    9799
    98100                def __unescape(self, s):
     
    168170                def error(self, token, i=0, tokens=None):
    169171                        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)
     172                                print('%s %s %s %s' % (tokens[i-3], tokens[i-2], tokens[i-1], tokens[i]))
     173                        raise Exception("Syntax error at or near %d:'%s' token" % (i, token))
    172174
    173175        class GdbMiInterpreter(spark.GenericASTTraversal):
     
    204206                                node.value = node[1].value
    205207                                for result in node[2].value:
    206                                         for n, v in result.items():
    207                                                 if node.value.has_key(n):
     208                                        for n, v in list(result.items()):
     209                                                if n in node.value:
    208210                                                        #print '**********list conversion: [%s] %s -> %s' % (n, node.value[n], v)
    209211                                                        old = node.value[n]
     
    214216                                                        node.value[n] = v
    215217                        else:
    216                                 raise Exception, 'Invalid tuple'
     218                                raise Exception('Invalid tuple')
    217219                        #print 'tuple: %s' % node.value
    218220
     
    306308                        return pprint.pformat(self.__dict__)
    307309
    308                 def __nonzero__(self):
     310                def __bool__(self):
    309311                        return len(self.__dict__) > 0
    310312
     
    321323
    322324                def graft(self, dict_):
    323                         for name, value in dict_.items():
     325                        for name, value in list(dict_.items()):
    324326                                name = name.replace('-', '_')
    325327                                if isinstance(value, dict):
     
    337339                def __init__(self, record):
    338340                        self.result = None
    339                         for name, value in record[0].items():
     341                        for name, value in list(record[0].items()):
    340342                                name = name.replace('-', '_')
    341343                                if name == 'results':
     
    364366def process(input):
    365367        tokens = scan(input)
    366         ast = parse(tokens)
     368        ast = parse(tokens)
    367369        __the_interpreter(ast)
    368370        return __the_output(ast.value)
     
    371373        def main():
    372374                def print_tokens(tokens):
    373                         print
     375                        print()
    374376                        for token in tokens:
    375377                                if token.value:
    376                                         print token.type + ': ' + token.value
     378                                        print(token.type + ': ' + token.value)
    377379                                else:
    378                                         print token.type
     380                                        print(token.type)
    379381
    380382                def run_test(test):
     
    387389                                __the_interpreter(ast)
    388390                                output = __the_output(ast.value)
    389                                 print output
     391                                print(output)
    390392
    391393                x = '"No symbol table is loaded.  Use the \\"file\\" command."'
  • tester/rt/pygdb/spark.py

    ra4c070c r4001a74  
    2020#  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    2121
     22from __future__ import print_function
     23
    2224__version__ = 'SPARK-0.7 (pre-alpha-7)'
    2325
     
    3133                for b in c.__bases__:
    3234                        classlist.append(b)
    33                 for name in c.__dict__.keys():
    34                         if not namedict.has_key(name):
     35                for name in list(c.__dict__.keys()):
     36                        if name not in namedict:
    3537                                namelist.append(name)
    3638                                namedict[name] = 1
     
    4345
    4446                self.index2func = {}
    45                 for name, number in self.re.groupindex.items():
     47                for name, number in list(self.re.groupindex.items()):
    4648                        self.index2func[number-1] = getattr(self, 't_' + name)
    4749
     
    5860
    5961                rv.append(self.makeRE('t_default'))
    60                 return string.join(rv, '|')
     62                return '|'.join(rv)
    6163
    6264        def error(self, s, pos):
    63                 print "Lexical error at position %s" % pos
     65                print("Lexical error at position %s" % pos)
    6466                raise SystemExit
    6567
     
    8284                        self.pos = m.end()
    8385                        for i in range(len(groups)):
    84                                 if groups[i] is not None and self.index2func.has_key(i):
     86                                if groups[i] is not None and i in self.index2func:
    8587                                        self.index2func[i](groups[i])
    8688
    8789        def t_default(self, s):
    8890                r'( . | \n )+'
    89                 print "Specification error: unmatched input"
     91                print("Specification error: unmatched input")
    9092                raise SystemExit
    9193
     
    146148                while changes:
    147149                        changes = 0
    148                         for k, v in self.edges.items():
     150                        for k, v in list(self.edges.items()):
    149151                                if v is None:
    150152                                        state, sym = k
    151                                         if self.states.has_key(state):
     153                                        if state in self.states:
    152154                                                self.goto(state, sym)
    153155                                                changes = 1
    154156                rv = self.__dict__.copy()
    155                 for s in self.states.values():
     157                for s in list(self.states.values()):
    156158                        del s.items
    157159                del rv['rule2func']
     
    180182        def addRule(self, doc, func, _preprocess=1):
    181183                fn = func
    182                 rules = string.split(doc)
     184                rules = doc.split()
    183185
    184186                index = []
     
    196198                                rule, fn = self.preprocess(rule, func)
    197199
    198                         if self.rules.has_key(lhs):
     200                        if lhs in self.rules:
    199201                                self.rules[lhs].append(rule)
    200202                        else:
     
    219221                tbd = []
    220222
    221                 for rulelist in self.rules.values():
     223                for rulelist in list(self.rules.values()):
    222224                        lhs = rulelist[0][0]
    223225                        self.nullable[lhs] = 0
     
    234236                                #
    235237                                for sym in rhs:
    236                                         if not self.rules.has_key(sym):
     238                                        if sym not in self.rules:
    237239                                                break
    238240                                else:
     
    268270        def makeNewRules(self):
    269271                worklist = []
    270                 for rulelist in self.rules.values():
     272                for rulelist in list(self.rules.values()):
    271273                        for rule in rulelist:
    272274                                worklist.append((rule, 0, 1, rule))
     
    277279                        while i < n:
    278280                                sym = rhs[i]
    279                                 if not self.rules.has_key(sym) or \
     281                                if sym not in self.rules or \
    280282                                   not self.nullable[sym]:
    281283                                        candidate = 0
     
    294296                                        lhs = self._NULLABLE+lhs
    295297                                        rule = (lhs, rhs)
    296                                 if self.newrules.has_key(lhs):
     298                                if lhs in self.newrules:
    297299                                        self.newrules[lhs].append(rule)
    298300                                else:
     
    304306
    305307        def error(self, token):
    306                 print "Syntax error at or near `%s' token" % token
     308                print("Syntax error at or near `%s' token" % token)
    307309                raise SystemExit
    308310
     
    321323                        self.makeState(0, self._BOF)
    322324
    323                 for i in xrange(len(tokens)):
     325                for i in range(len(tokens)):
    324326                        sets.append([])
    325327
     
    350352                return self._NULLABLE == sym[0:len(self._NULLABLE)]
    351353
    352         def skip(self, (lhs, rhs), pos=0):
     354        def skip(self, xxx_todo_changeme, pos=0):
     355                (lhs, rhs) = xxx_todo_changeme
    353356                n = len(rhs)
    354357                while pos < n:
     
    373376                core.sort()
    374377                tcore = tuple(core)
    375                 if self.cores.has_key(tcore):
     378                if tcore in self.cores:
    376379                        return self.cores[tcore]
    377380                #
     
    397400                                nextSym = rhs[pos]
    398401                                key = (X.stateno, nextSym)
    399                                 if not rules.has_key(nextSym):
    400                                         if not edges.has_key(key):
     402                                if nextSym not in rules:
     403                                        if key not in edges:
    401404                                                edges[key] = None
    402405                                                X.T.append(nextSym)
    403406                                else:
    404407                                        edges[key] = None
    405                                         if not predicted.has_key(nextSym):
     408                                        if nextSym not in predicted:
    406409                                                predicted[nextSym] = 1
    407410                                                for prule in rules[nextSym]:
     
    427430                #  to do this without accidentally duplicating states.
    428431                #
    429                 core = predicted.keys()
     432                core = list(predicted.keys())
    430433                core.sort()
    431434                tcore = tuple(core)
    432                 if self.cores.has_key(tcore):
     435                if tcore in self.cores:
    433436                        self.edges[(k, None)] = self.cores[tcore]
    434437                        return k
     
    441444        def goto(self, state, sym):
    442445                key = (state, sym)
    443                 if not self.edges.has_key(key):
     446                if key not in self.edges:
    444447                        #
    445448                        #  No transitions from state on sym.
     
    639642                for i in range(len(rhs)-1, -1, -1):
    640643                        sym = rhs[i]
    641                         if not self.newrules.has_key(sym):
     644                        if sym not in self.newrules:
    642645                                if sym != self._BOF:
    643646                                        attr[i] = tokens[k-1]
     
    669672                        name2index[name] = i
    670673                sortlist.sort()
    671                 list = map(lambda (a,b): b, sortlist)
     674                list = [a_b[1] for a_b in sortlist]
    672675                return rules[name2index[self.resolve(list)]]
    673676
     
    834837def _dump(tokens, sets, states):
    835838        for i in range(len(sets)):
    836                 print 'set', i
     839                print('set', i)
    837840                for item in sets[i]:
    838                         print '\t', item
     841                        print('\t', item)
    839842                        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:])
     843                                print('\t\t', lhs, '::=', end=' ')
     844                                print(string.join(rhs[:pos]), end=' ')
     845                                print('.', end=' ')
     846                                print(string.join(rhs[pos:]))
    844847                if i < len(tokens):
    845                         print
    846                         print 'token', str(tokens[i])
    847                         print
     848                        print()
     849                        print('token', str(tokens[i]))
     850                        print()
  • tester/rt/stty.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2013-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2013-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3232# RTEMS Testing Consoles
    3333#
     34
     35from __future__ import print_function
    3436
    3537import os
     
    7375        try:
    7476            self.fd = open(dev, 'rw')
    75         except IOError, ioe:
     77        except IOError as ioe:
    7678            raise error.general('opening tty dev: %s: %s' % (dev, ioe))
    7779        except:
     
    559561        t.vmin(1)
    560562        t.vtime(2)
    561         print t
     563        print(t)
    562564        t.set('B115200,~BRKINT,IGNBRK,IGNCR,~ICANON,~ISIG,~IEXTEN,~ECHO,CLOCAL,~CRTSCTS')
    563         print t
     565        print(t)
    564566        t.on()
    565567        while True:
  • tester/rt/test.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2013-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2013-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    2929#
    3030
     31from __future__ import print_function
     32
    3133import copy
    3234import datetime
     35import fnmatch
    3336import os
    3437import sys
     
    4245from rtemstoolkit import version
    4346
    44 import bsps
    45 import config
    46 import console
    47 import options
    48 import report
    49 import fnmatch
     47from . import bsps
     48from . import config
     49from . import console
     50from . import options
     51from . import report
    5052
    5153class test(object):
     
    119121    def reraise(self):
    120122        if self.result is not None:
    121             raise self.result[0], self.result[1], self.result[2]
     123            raise self.result[0](self.result[1]).with_traceback(self.result[2])
    122124
    123125    def kill(self):
     
    158160            del reported[:]
    159161            if job_trace:
    160                 print '}} threading:', threading.active_count()
     162                print('}} threading:', threading.active_count())
    161163                for t in threading.enumerate():
    162                     print '}} ', t.name
     164                    print('}} ', t.name)
    163165    return reporting
    164166
     
    303305        log.notice('Average test time: %s' % (str((end_time - start_time) / total)))
    304306        log.notice('Testing time     : %s' % (str(end_time - start_time)))
    305     except error.general, gerr:
    306         print gerr
     307    except error.general as gerr:
     308        print(gerr)
    307309        sys.exit(1)
    308     except error.internal, ierr:
    309         print ierr
     310    except error.internal as ierr:
     311        print(ierr)
    310312        sys.exit(1)
    311     except error.exit, eerr:
     313    except error.exit as eerr:
    312314        sys.exit(2)
    313315    except KeyboardInterrupt:
    314316        if opts is not None and opts.find_arg('--stacktrace'):
    315             print '}} dumping:', threading.active_count()
     317            print('}} dumping:', threading.active_count())
    316318            for t in threading.enumerate():
    317                 print '}} ', t.name
    318             print stacktraces.trace()
     319                print('}} ', t.name)
     320            print(stacktraces.trace())
    319321        log.notice('abort: user terminated')
    320322        killall(tests)
  • tester/rt/version.py

    ra4c070c r4001a74  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2013-2014 Chris Johns (chrisj@rtems.org)
     3# Copyright 2013-2016 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    2929#
    3030
    31 #
    32 # Manage paths locally. The internally the path is in Unix or shell format and
    33 # we convert to the native format when performing operations at the Python
    34 # level. This allows macro expansion to work.
    35 #
     31from __future__ import print_function
    3632
    3733major = 0
     
    4339
    4440if __name__ == '__main__':
    45     print 'major = %d' % (major)
    46     print 'minor = %d' % (minor)
    47     print 'revision = %d' % (revision)
    48     print 'Version: %s' % (str())
     41    print('major = %d' % (major))
     42    print('minor = %d' % (minor))
     43    print('revision = %d' % (revision))
     44    print('Version: %s' % (str()))
  • tester/rtems-test

    ra4c070c r4001a74  
    22#
    33# RTEMS Tools Project (http://www.rtems.org/)
    4 # Copyright 2013, 2015 Chris Johns (chrisj@rtems.org)
     4# Copyright 2013-2016 Chris Johns (chrisj@rtems.org)
    55# All rights reserved.
    66#
     
    3030#
    3131
     32from __future__ import print_function
     33
    3234import sys, os
    3335base = os.path.dirname(os.path.abspath(sys.argv[0]))
     
    4042    rt.test.run()
    4143except ImportError:
    42     print >> sys.stderr, "Incorrect RTEMS Tools installation"
     44    print("Incorrect RTEMS Tools installation", file = sys.stderr)
    4345    sys.exit(1)
Note: See TracChangeset for help on using the changeset viewer.