Changeset b0fa2ae in rtems-tools for tester


Ignore:
Timestamp:
Mar 3, 2016, 5:46:18 AM (4 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, master
Children:
a5d243d
Parents:
0e5d89d
git-author:
Chris Johns <chrisj@…> (03/03/16 05:46:18)
git-committer:
Chris Johns <chrisj@…> (03/03/16 05:53:39)
Message:

Update rtems-tool to support Python 2 and 3.

Add solaris and netbsd.

Close #2619.

Location:
tester
Files:
1 deleted
9 edited

Legend:

Unmodified
Added
Removed
  • tester/rt/config.py

    r0e5d89d rb0fa2ae  
    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
  • tester/rt/console.py

    r0e5d89d rb0fa2ae  
    3333#
    3434
     35from __future__ import print_function
     36
    3537import errno
    3638import os
     
    4345if os.name != 'nt':
    4446    import fcntl
    45     import stty
     47    from . import stty
    4648else:
    4749    fcntl = None
  • tester/rt/gdb.py

    r0e5d89d rb0fa2ae  
    3333#
    3434
     35from __future__ import print_function
     36
    3537import os
    36 import Queue
     38try:
     39    import Queue
     40    queue = Queue
     41except ImportError:
     42    import queue
    3743import sys
    3844import threading
     
    4349from rtemstoolkit import path
    4450
    45 import console
    46 import pygdb
     51#
     52# Support to handle use in a package and as a unit test.
     53# If there is a better way to let us know.
     54#
     55try:
     56    from . import console
     57    from . import pygdb
     58except (ValueError, SystemError):
     59    import console
     60    import pygdb
    4761
    4862#
     
    6579        self.output = None
    6680        self.gdb_console = None
    67         self.input = Queue.Queue()
    68         self.commands = Queue.Queue()
     81        self.input = queue.Queue()
     82        self.commands = queue.Queue()
    6983        self.process = None
    7084        self.state = {}
     
    140154                if self.trace:
    141155                    print('>>> input: queue=%d' % (self.input.qsize()), line)
    142             except Queue.Empty:
     156            except queue.Empty:
    143157                return True
    144158            if line is None:
  • tester/rt/options.py

    r0e5d89d rb0fa2ae  
    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#
     
    116117        log.notice(str(_opts.defaults))
    117118    except error.general as gerr:
    118         print(gerr)
     119        print(gerr, file = sys.stderr)
    119120        sys.exit(1)
    120121    except error.internal as ierr:
    121         print(ierr)
     122        print(ierr, file = sys.stderr)
    122123        sys.exit(1)
    123124    except error.exit:
  • tester/rt/pygdb/__init__.py

    r0e5d89d rb0fa2ae  
    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

    r0e5d89d rb0fa2ae  
    2929# $Id$
    3030
     31from __future__ import print_function
    3132
    3233import re
    3334import pprint
    34 import spark
     35
     36from . import spark
    3537
    3638def __private():
     
    191193                        # result ::= variable = value
    192194                        node.value = { node[0].value: node[2].value }
    193                         #print('result: %s' % node.value)
     195                        #print 'result: %s' % node.value
    194196
    195197                def n_tuple(self, node):
     
    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                                                         #print('**********list conversion: [%s] %s -> %s' % (n, node.value[n], v))
     208                                        for n, v in list(result.items()):
     209                                                if n in node.value:
     210                                                        #print '**********list conversion: [%s] %s -> %s' % (n, node.value[n], v)
    209211                                                        old = node.value[n]
    210212                                                        if not isinstance(old, list):
     
    215217                        else:
    216218                                raise Exception('Invalid tuple')
    217                         #print('tuple: %s' % node.value)
     219                        #print 'tuple: %s' % node.value
    218220
    219221                def n_list(self, node):
     
    231233                                #list ::= { value }
    232234                                #list ::= { value value_list }
    233                         #print('list %s' % node.value)
     235                        #print 'list %s' % node.value
    234236
    235237                def n_value_list(self, node):
     
    248250                                # result_list ::= , result result_list
    249251                                node.value = [ node[1].value ] + node[2].value
    250                         #print('result_list: %s' % node.value)
     252                        #print 'result_list: %s' % node.value
    251253
    252254                def n_result_record(self, node):
     
    258260                                # result_record ::= result_header nl
    259261                                pass
    260                         #print('result_record: %s' % (node.value))
     262                        #print 'result_record: %s' % (node.value)
    261263
    262264                def n_result_header(self, node):
     
    285287                                'record_type': 'stream'
    286288                        }
    287                         #print('stream_record: %s' % node.value)
     289                        #print 'stream_record: %s' % node.value
    288290
    289291                def n_record_list(self, node):
     
    294296                                # record_list ::= generic_record record_list
    295297                                node.value = [ node[0].value ] + node[1].value
    296                         #print('record_list: %s' % node.value)
     298                        #print 'record_list: %s' % node.value
    297299
    298300                #def default(self, node):
    299                         #print('default: ' + node.type)
     301                        #print 'default: ' + node.type
    300302
    301303        class GdbDynamicObject:
     
    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':
     
    371373        def main():
    372374                def print_tokens(tokens):
    373                         print
     375                        print()
    374376                        for token in tokens:
    375377                                if token.value:
  • tester/rt/pygdb/spark.py

    r0e5d89d rb0fa2ae  
    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):
     
    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
     
    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:
     
    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):
    353                 lhs, rhs = lhs_rhs
     354        def skip(self, xxx_todo_changeme, pos=0):
     355                (lhs, rhs) = xxx_todo_changeme
    354356                n = len(rhs)
    355357                while pos < n:
     
    374376                core.sort()
    375377                tcore = tuple(core)
    376                 if self.cores.has_key(tcore):
     378                if tcore in self.cores:
    377379                        return self.cores[tcore]
    378380                #
     
    398400                                nextSym = rhs[pos]
    399401                                key = (X.stateno, nextSym)
    400                                 if not rules.has_key(nextSym):
    401                                         if not edges.has_key(key):
     402                                if nextSym not in rules:
     403                                        if key not in edges:
    402404                                                edges[key] = None
    403405                                                X.T.append(nextSym)
    404406                                else:
    405407                                        edges[key] = None
    406                                         if not predicted.has_key(nextSym):
     408                                        if nextSym not in predicted:
    407409                                                predicted[nextSym] = 1
    408410                                                for prule in rules[nextSym]:
     
    428430                #  to do this without accidentally duplicating states.
    429431                #
    430                 core = predicted.keys()
     432                core = list(predicted.keys())
    431433                core.sort()
    432434                tcore = tuple(core)
    433                 if self.cores.has_key(tcore):
     435                if tcore in self.cores:
    434436                        self.edges[(k, None)] = self.cores[tcore]
    435437                        return k
     
    442444        def goto(self, state, sym):
    443445                key = (state, sym)
    444                 if not self.edges.has_key(key):
     446                if key not in self.edges:
    445447                        #
    446448                        #  No transitions from state on sym.
     
    614616                else:
    615617                        rule = self.newrules[nt][0]
    616                 #print(rule)
     618                #print rule
    617619
    618620                rhs = rule[1]
     
    633635                if len(choices) > 1:
    634636                        rule = self.ambiguity(choices)
    635                 #print(rule)
     637                #print rule
    636638
    637639                rhs = rule[1]
     
    640642                for i in range(len(rhs)-1, -1, -1):
    641643                        sym = rhs[i]
    642                         if not self.newrules.has_key(sym):
     644                        if sym not in self.newrules:
    643645                                if sym != self._BOF:
    644646                                        attr[i] = tokens[k-1]
     
    670672                        name2index[name] = i
    671673                sortlist.sort()
    672                 list = list(map(lambda a,b: b, sortlist))
     674                list = [a_b[1] for a_b in sortlist]
    673675                return rules[name2index[self.resolve(list)]]
    674676
     
    839841                        print('\t', item)
    840842                        for (lhs, rhs), pos in states[item[0]].items:
    841                                 print('\t\t', lhs, '::=',)
    842                                 print(string.join(rhs[:pos]),)
    843                                 print('.',)
     843                                print('\t\t', lhs, '::=', end=' ')
     844                                print(string.join(rhs[:pos]), end=' ')
     845                                print('.', end=' ')
    844846                                print(string.join(rhs[pos:]))
    845847                if i < len(tokens):
    846                         print
     848                        print()
    847849                        print('token', str(tokens[i]))
    848                         print
     850                        print()
  • tester/rt/test.py

    r0e5d89d rb0fa2ae  
    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):
  • tester/rtems-test

    r0e5d89d rb0fa2ae  
    3636sys.path = [parent, rtems, os.path.join(rtems, 'tester')] + sys.path
    3737
    38 import rt.test
    39 rt.test.run()
    40 
    4138try:
    4239    import rt.test
Note: See TracChangeset for help on using the changeset viewer.