Author: Philip Jenvey <pjen...@underboss.org> Branch: py3.3 Changeset: r75152:c393dc8e0fc4 Date: 2014-12-29 13:15 -0800 http://bitbucket.org/pypy/pypy/changeset/c393dc8e0fc4/
Log: merge py3k diff too long, truncating to 2000 out of 15290 lines diff --git a/README.rst b/README.rst --- a/README.rst +++ b/README.rst @@ -37,4 +37,4 @@ to use virtualenv with the resulting pypy-c as the interpreter; you can find more details about various installation schemes here: -http://doc.pypy.org/en/latest/getting-started.html#installing-pypy + http://doc.pypy.org/en/latest/install.html diff --git a/lib-python/2.7/subprocess.py b/lib-python/2.7/subprocess.py --- a/lib-python/2.7/subprocess.py +++ b/lib-python/2.7/subprocess.py @@ -655,6 +655,21 @@ """Create new Popen instance.""" _cleanup() + # --- PyPy hack, see _pypy_install_libs_after_virtualenv() --- + # match arguments passed by different versions of virtualenv + if args[1:] in ( + ['-c', 'import sys; print(sys.prefix)'], # 1.6 10ba3f3c + ['-c', "\nimport sys\nprefix = sys.prefix\n" # 1.7 0e9342ce + "if sys.version_info[0] == 3:\n" + " prefix = prefix.encode('utf8')\n" + "if hasattr(sys.stdout, 'detach'):\n" + " sys.stdout = sys.stdout.detach()\n" + "elif hasattr(sys.stdout, 'buffer'):\n" + " sys.stdout = sys.stdout.buffer\nsys.stdout.write(prefix)\n"], + ['-c', 'import sys;out=sys.stdout;getattr(out, "buffer"' + ', out).write(sys.prefix.encode("utf-8"))']): # 1.7.2 a9454bce + _pypy_install_libs_after_virtualenv(args[0]) + if not isinstance(bufsize, (int, long)): raise TypeError("bufsize must be an integer") @@ -1560,6 +1575,27 @@ self.send_signal(signal.SIGKILL) +def _pypy_install_libs_after_virtualenv(target_executable): + # https://bitbucket.org/pypy/pypy/issue/1922/future-proofing-virtualenv + # + # PyPy 2.4.1 turned --shared on by default. This means the pypy binary + # depends on the 'libpypy-c.so' shared library to be able to run. + # The virtualenv code existing at the time did not account for this + # and would break. Try to detect that we're running under such a + # virtualenv in the "Testing executable with" phase and copy the + # library ourselves. + caller = sys._getframe(2) + if ('virtualenv_version' in caller.f_globals and + 'copyfile' in caller.f_globals): + dest_dir = sys.pypy_resolvedirof(target_executable) + src_dir = sys.pypy_resolvedirof(sys.executable) + for libname in ['libpypy-c.so']: + dest_library = os.path.join(dest_dir, libname) + src_library = os.path.join(src_dir, libname) + if os.path.exists(src_library): + caller.f_globals['copyfile'](src_library, dest_library) + + def _demo_posix(): # # Example 1: Simple redirection: Get process list diff --git a/lib-python/conftest.py b/lib-python/conftest.py --- a/lib-python/conftest.py +++ b/lib-python/conftest.py @@ -60,7 +60,7 @@ skip=None): self.basename = basename self._usemodules = usemodules.split() + [ - '_socket', 'binascii', 'rctime', + '_socket', 'binascii', 'time', 'select', 'signal', 'faulthandler'] if not sys.platform == 'win32': self._usemodules.extend(['_posixsubprocess', 'fcntl']) diff --git a/lib_pypy/_curses.py b/lib_pypy/_curses.py --- a/lib_pypy/_curses.py +++ b/lib_pypy/_curses.py @@ -1127,6 +1127,8 @@ if term is None: term = ffi.NULL + elif isinstance(term, str): + term = term.encode('utf-8') err = ffi.new("int *") if lib.setupterm(term, fd, err) == lib.ERR: err = err[0] diff --git a/lib_pypy/grp.py b/lib_pypy/grp.py --- a/lib_pypy/grp.py +++ b/lib_pypy/grp.py @@ -72,7 +72,7 @@ raise TypeError("expected string") res = libc.getgrnam(os.fsencode(name)) if not res: - raise KeyError(name) + raise KeyError("'getgrnam(): name not found: %s'" % name) return _group_from_gstruct(res) @builtinify diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py --- a/pypy/config/pypyoption.py +++ b/pypy/config/pypyoption.py @@ -30,7 +30,7 @@ # --allworkingmodules working_modules = default_modules.copy() working_modules.update([ - "_socket", "unicodedata", "mmap", "fcntl", "_locale", "pwd", "rctime" , + "_socket", "unicodedata", "mmap", "fcntl", "_locale", "pwd", "time" , "select", "zipimport", "_lsprof", "crypt", "signal", "_rawffi", "termios", "zlib", "bz2", "struct", "_hashlib", "_md5", "_minimal_curses", "thread", "itertools", "pyexpat", "_ssl", "cpyext", "array", @@ -42,7 +42,7 @@ translation_modules = default_modules.copy() translation_modules.update([ - "fcntl", "rctime", "select", "signal", "_rawffi", "zlib", "struct", + "fcntl", "time", "select", "signal", "_rawffi", "zlib", "struct", "array", "binascii", # the following are needed for pyrepl (and hence for the # interactive prompt/pdb) @@ -67,19 +67,15 @@ default_modules.add("_locale") if sys.platform == "sunos5": - working_modules.remove('mmap') # depend on ctypes, can't get at c-level 'errono' - working_modules.remove('rctime') # depend on ctypes, missing tm_zone/tm_gmtoff - working_modules.remove('signal') # depend on ctypes, can't get at c-level 'errono' working_modules.remove('fcntl') # LOCK_NB not defined working_modules.remove("_minimal_curses") working_modules.remove("termios") - working_modules.remove("_multiprocessing") # depends on rctime if "cppyy" in working_modules: working_modules.remove("cppyy") # depends on ctypes module_dependencies = { - '_multiprocessing': [('objspace.usemodules.rctime', True), + '_multiprocessing': [('objspace.usemodules.time', True), ('objspace.usemodules.thread', True)], 'cpyext': [('objspace.usemodules.array', True)], 'cppyy': [('objspace.usemodules.cpyext', True)], @@ -89,9 +85,10 @@ # itself needs the interp-level struct module # because 'P' is missing from the app-level one "_rawffi": [("objspace.usemodules.struct", True)], - "cpyext": [("translation.secondaryentrypoints", "cpyext,main"), - ("translation.shared", sys.platform == "win32")], + "cpyext": [("translation.secondaryentrypoints", "cpyext,main")], } +if sys.platform == "win32": + module_suggests["cpyext"].append(("translation.shared", True)) module_import_dependencies = { # no _rawffi if importing rpython.rlib.clibffi raises ImportError diff --git a/pypy/doc/config/objspace.usemodules.rctime.txt b/pypy/doc/config/objspace.usemodules.rctime.txt deleted file mode 100644 --- a/pypy/doc/config/objspace.usemodules.rctime.txt +++ /dev/null @@ -1,7 +0,0 @@ -Use the 'rctime' module. - -'rctime' is our `rffi`_ based implementation of the builtin 'time' module. -It supersedes the less complete :config:`objspace.usemodules.time`, -at least for C-like targets (the C and LLVM backends). - -.. _`rffi`: ../rffi.html diff --git a/pypy/doc/config/objspace.usemodules.time.txt b/pypy/doc/config/objspace.usemodules.time.txt --- a/pypy/doc/config/objspace.usemodules.time.txt +++ b/pypy/doc/config/objspace.usemodules.time.txt @@ -1,5 +1,1 @@ Use the 'time' module. - -Obsolete; use :config:`objspace.usemodules.rctime` for our up-to-date version -of the application-level 'time' module, at least for C-like targets (the C -and LLVM backends). diff --git a/pypy/doc/cpython_differences.rst b/pypy/doc/cpython_differences.rst --- a/pypy/doc/cpython_differences.rst +++ b/pypy/doc/cpython_differences.rst @@ -205,23 +205,28 @@ The above is true both in CPython and in PyPy. Differences can occur about whether a built-in function or method will call an overridden method of *another* object than ``self``. -In PyPy, they are generally always called, whereas not in -CPython. For example, in PyPy, ``dict1.update(dict2)`` -considers that ``dict2`` is just a general mapping object, and -will thus call overridden ``keys()`` and ``__getitem__()`` -methods on it. So the following code prints ``42`` on PyPy -but ``foo`` on CPython:: +In PyPy, they are often called in cases where CPython would not. +Two examples:: - >>>> class D(dict): - .... def __getitem__(self, key): - .... return 42 - .... - >>>> - >>>> d1 = {} - >>>> d2 = D(a='foo') - >>>> d1.update(d2) - >>>> print d1['a'] - 42 + class D(dict): + def __getitem__(self, key): + return "%r from D" % (key,) + + class A(object): + pass + + a = A() + a.__dict__ = D() + a.foo = "a's own foo" + print a.foo + # CPython => a's own foo + # PyPy => 'foo' from D + + glob = D(foo="base item") + loc = {} + exec "print foo" in glob, loc + # CPython => base item + # PyPy => 'foo' from D Mutating classes of objects which are already used as dictionary keys @@ -292,6 +297,9 @@ above types will return a value that is computed from the argument, and can thus be larger than ``sys.maxint`` (i.e. it can be an arbitrary long). +Notably missing from the list above are ``str`` and ``unicode``. If your +code relies on comparing strings with ``is``, then it might break in PyPy. + Miscellaneous ------------- diff --git a/pypy/doc/whatsnew-head.rst b/pypy/doc/whatsnew-head.rst --- a/pypy/doc/whatsnew-head.rst +++ b/pypy/doc/whatsnew-head.rst @@ -39,3 +39,15 @@ .. branch: kill-multimethod Kill multimethod machinery, all multimethods were removed earlier. + +.. branch nditer-external_loop + +Implement `external_loop` arguement to numpy's nditer + +.. branch kill-rctime + +Rename pypy/module/rctime to pypy/module/time, since it contains the implementation of the 'time' module. + +.. branch: ssa-flow + +Use SSA form for flow graphs inside build_flow() and part of simplify_graph() diff --git a/pypy/interpreter/astcompiler/assemble.py b/pypy/interpreter/astcompiler/assemble.py --- a/pypy/interpreter/astcompiler/assemble.py +++ b/pypy/interpreter/astcompiler/assemble.py @@ -1,15 +1,13 @@ -""" -Python control flow graph generation and bytecode assembly. -""" +"""Python control flow graph generation and bytecode assembly.""" -from pypy.interpreter.astcompiler import ast, consts, symtable -from pypy.interpreter import pycode +from rpython.rlib import rfloat +from rpython.rlib.objectmodel import specialize, we_are_translated + +from pypy.interpreter.astcompiler import ast, consts, misc, symtable +from pypy.interpreter.error import OperationError +from pypy.interpreter.pycode import PyCode from pypy.tool import stdlib_opcode as ops -from pypy.interpreter.error import OperationError -from rpython.rlib.objectmodel import specialize, we_are_translated -from rpython.rlib import rfloat - class Instruction(object): """Represents a single opcode.""" @@ -21,14 +19,12 @@ self.has_jump = False def size(self): - """Return the size of bytes of this instruction when it is encoded.""" + """Return the size of bytes of this instruction when it is + encoded. + """ if self.opcode >= ops.HAVE_ARGUMENT: - if self.arg > 0xFFFF: - return 6 - else: - return 3 - else: - return 1 + return (6 if self.arg > 0xFFFF else 3) + return 1 def jump_to(self, target, absolute=False): """Indicate the target this jump instruction. @@ -54,9 +50,9 @@ class Block(object): """A basic control flow block. - It has one entry point and several possible exit points. Its instructions - may be jumps to other blocks, or if control flow reaches the end of the - block, it continues to next_block. + It has one entry point and several possible exit points. Its + instructions may be jumps to other blocks, or if control flow + reaches the end of the block, it continues to next_block. """ def __init__(self): @@ -71,10 +67,10 @@ stack.append(nextblock) def post_order(self): - """Return this block and its children in post order. - This means that the graph of blocks is first cleaned up to - ignore back-edges, thus turning it into a DAG. Then the DAG - is linearized. For example: + """Return this block and its children in post order. This means + that the graph of blocks is first cleaned up to ignore + back-edges, thus turning it into a DAG. Then the DAG is + linearized. For example: A --> B -\ => [A, D, B, C] \-> D ---> C @@ -105,7 +101,9 @@ return resultblocks def code_size(self): - """Return the encoded size of all the instructions in this block.""" + """Return the encoded size of all the instructions in this + block. + """ i = 0 for instr in self.instructions: i += instr.size() @@ -141,6 +139,7 @@ i += 1 return result + @specialize.argtype(0) def _iter_to_dict(iterable, offset=0): result = {} @@ -302,11 +301,11 @@ def _resolve_block_targets(self, blocks): """Compute the arguments of jump instructions.""" last_extended_arg_count = 0 - # The reason for this loop is extended jumps. EXTENDED_ARG extends the - # bytecode size, so it might invalidate the offsets we've already given. - # Thus we have to loop until the number of extended args is stable. Any - # extended jump at all is extremely rare, so performance is not too - # concerning. + # The reason for this loop is extended jumps. EXTENDED_ARG + # extends the bytecode size, so it might invalidate the offsets + # we've already given. Thus we have to loop until the number of + # extended args is stable. Any extended jump at all is + # extremely rare, so performance is not too concerning. while True: extended_arg_count = 0 offset = 0 @@ -332,7 +331,8 @@ instr.opcode = ops.JUMP_ABSOLUTE absolute = True elif target_op == ops.RETURN_VALUE: - # Replace JUMP_* to a RETURN into just a RETURN + # Replace JUMP_* to a RETURN into + # just a RETURN instr.opcode = ops.RETURN_VALUE instr.arg = 0 instr.has_jump = False @@ -347,7 +347,8 @@ instr.arg = jump_arg if jump_arg > 0xFFFF: extended_arg_count += 1 - if extended_arg_count == last_extended_arg_count and not force_redo: + if (extended_arg_count == last_extended_arg_count and + not force_redo): break else: last_extended_arg_count = extended_arg_count @@ -362,12 +363,14 @@ while True: try: w_key = space.next(w_iter) - except OperationError, e: + except OperationError as e: if not e.match(space, space.w_StopIteration): raise break w_index = space.getitem(w_consts, w_key) - consts_w[space.int_w(w_index)] = space.getitem(w_key, first) + w_constant = space.getitem(w_key, first) + w_constant = misc.intern_if_common_string(space, w_constant) + consts_w[space.int_w(w_index)] = w_constant return consts_w def _get_code_flags(self): @@ -435,15 +438,16 @@ continue addr = offset - current_off # Python assumes that lineno always increases with - # increasing bytecode address (lnotab is unsigned char). - # Depending on when SET_LINENO instructions are emitted this - # is not always true. Consider the code: + # increasing bytecode address (lnotab is unsigned + # char). Depending on when SET_LINENO instructions + # are emitted this is not always true. Consider the + # code: # a = (1, # b) - # In the bytecode stream, the assignment to "a" occurs after - # the loading of "b". This works with the C Python compiler - # because it only generates a SET_LINENO instruction for the - # assignment. + # In the bytecode stream, the assignment to "a" + # occurs after the loading of "b". This works with + # the C Python compiler because it only generates a + # SET_LINENO instruction for the assignment. if line or addr: while addr > 255: push(chr(255)) @@ -488,23 +492,23 @@ # (Only) inherit compilerflags in PyCF_MASK flags |= (self.compile_info.flags & consts.PyCF_MASK) bytecode = ''.join([block.get_code() for block in blocks]) - return pycode.PyCode(self.space, - self.argcount, - self.kwonlyargcount, - len(self.var_names), - stack_depth, - flags, - bytecode, - list(consts_w), - names, - var_names, - self.compile_info.filename, - self.name, - self.first_lineno, - lnotab, - free_names, - cell_names, - self.compile_info.hidden_applevel) + return PyCode(self.space, + self.argcount, + self.kwonlyargcount, + len(self.var_names), + stack_depth, + flags, + bytecode, + list(consts_w), + names, + var_names, + self.compile_info.filename, + self.name, + self.first_lineno, + lnotab, + free_names, + cell_names, + self.compile_info.hidden_applevel) def _list_from_dict(d, offset=0): @@ -515,116 +519,116 @@ _static_opcode_stack_effects = { - ops.NOP : 0, + ops.NOP: 0, - ops.POP_TOP : -1, - ops.ROT_TWO : 0, - ops.ROT_THREE : 0, - ops.DUP_TOP : 1, - ops.DUP_TOP_TWO : 2, + ops.POP_TOP: -1, + ops.ROT_TWO: 0, + ops.ROT_THREE: 0, + ops.DUP_TOP: 1, + ops.DUP_TOP_TWO: 2, - ops.UNARY_POSITIVE : 0, - ops.UNARY_NEGATIVE : 0, - ops.UNARY_NOT : 0, - ops.UNARY_INVERT : 0, + ops.UNARY_POSITIVE: 0, + ops.UNARY_NEGATIVE: 0, + ops.UNARY_NOT: 0, + ops.UNARY_INVERT: 0, - ops.LIST_APPEND : -1, - ops.SET_ADD : -1, - ops.MAP_ADD : -2, - ops.STORE_MAP : -2, + ops.LIST_APPEND: -1, + ops.SET_ADD: -1, + ops.MAP_ADD: -2, + ops.STORE_MAP: -2, - ops.BINARY_POWER : -1, - ops.BINARY_MULTIPLY : -1, - ops.BINARY_MODULO : -1, - ops.BINARY_ADD : -1, - ops.BINARY_SUBTRACT : -1, - ops.BINARY_SUBSCR : -1, - ops.BINARY_FLOOR_DIVIDE : -1, - ops.BINARY_TRUE_DIVIDE : -1, - ops.BINARY_LSHIFT : -1, - ops.BINARY_RSHIFT : -1, - ops.BINARY_AND : -1, - ops.BINARY_OR : -1, - ops.BINARY_XOR : -1, + ops.BINARY_POWER: -1, + ops.BINARY_MULTIPLY: -1, + ops.BINARY_MODULO: -1, + ops.BINARY_ADD: -1, + ops.BINARY_SUBTRACT: -1, + ops.BINARY_SUBSCR: -1, + ops.BINARY_FLOOR_DIVIDE: -1, + ops.BINARY_TRUE_DIVIDE: -1, + ops.BINARY_LSHIFT: -1, + ops.BINARY_RSHIFT: -1, + ops.BINARY_AND: -1, + ops.BINARY_OR: -1, + ops.BINARY_XOR: -1, - ops.INPLACE_FLOOR_DIVIDE : -1, - ops.INPLACE_TRUE_DIVIDE : -1, - ops.INPLACE_ADD : -1, - ops.INPLACE_SUBTRACT : -1, - ops.INPLACE_MULTIPLY : -1, - ops.INPLACE_MODULO : -1, - ops.INPLACE_POWER : -1, - ops.INPLACE_LSHIFT : -1, - ops.INPLACE_RSHIFT : -1, - ops.INPLACE_AND : -1, - ops.INPLACE_OR : -1, - ops.INPLACE_XOR : -1, + ops.INPLACE_FLOOR_DIVIDE: -1, + ops.INPLACE_TRUE_DIVIDE: -1, + ops.INPLACE_ADD: -1, + ops.INPLACE_SUBTRACT: -1, + ops.INPLACE_MULTIPLY: -1, + ops.INPLACE_MODULO: -1, + ops.INPLACE_POWER: -1, + ops.INPLACE_LSHIFT: -1, + ops.INPLACE_RSHIFT: -1, + ops.INPLACE_AND: -1, + ops.INPLACE_OR: -1, + ops.INPLACE_XOR: -1, - ops.STORE_SUBSCR : -2, - ops.DELETE_SUBSCR : -2, + ops.STORE_SUBSCR: -2, + ops.DELETE_SUBSCR: -2, - ops.GET_ITER : 0, - ops.FOR_ITER : 1, - ops.BREAK_LOOP : 0, - ops.CONTINUE_LOOP : 0, - ops.SETUP_LOOP : 0, + ops.GET_ITER: 0, + ops.FOR_ITER: 1, + ops.BREAK_LOOP: 0, + ops.CONTINUE_LOOP: 0, + ops.SETUP_LOOP: 0, - ops.PRINT_EXPR : -1, + ops.PRINT_EXPR: -1, - ops.WITH_CLEANUP : -1, - ops.LOAD_BUILD_CLASS : 1, - ops.STORE_LOCALS : -1, - ops.POP_BLOCK : 0, - ops.POP_EXCEPT : 0, - ops.END_FINALLY : -1, - ops.SETUP_WITH : 1, - ops.SETUP_FINALLY : 0, - ops.SETUP_EXCEPT : 4, + ops.WITH_CLEANUP: -1, + ops.LOAD_BUILD_CLASS: 1, + ops.STORE_LOCALS: -1, + ops.POP_BLOCK: 0, + ops.POP_EXCEPT: 0, + ops.END_FINALLY: -1, + ops.SETUP_WITH: 1, + ops.SETUP_FINALLY: 0, + ops.SETUP_EXCEPT: 4, - ops.RETURN_VALUE : -1, - ops.YIELD_VALUE : 0, - ops.YIELD_FROM : -1, - ops.BUILD_MAP : 1, - ops.BUILD_SET : 1, - ops.COMPARE_OP : -1, + ops.RETURN_VALUE: -1, + ops.YIELD_VALUE: 0, + ops.YIELD_FROM: -1, + ops.BUILD_MAP: 1, + ops.BUILD_SET: 1, + ops.COMPARE_OP: -1, - ops.LOOKUP_METHOD : 1, + ops.LOOKUP_METHOD: 1, - ops.LOAD_NAME : 1, - ops.STORE_NAME : -1, - ops.DELETE_NAME : 0, + ops.LOAD_NAME: 1, + ops.STORE_NAME: -1, + ops.DELETE_NAME: 0, - ops.LOAD_FAST : 1, - ops.STORE_FAST : -1, - ops.DELETE_FAST : 0, + ops.LOAD_FAST: 1, + ops.STORE_FAST: -1, + ops.DELETE_FAST: 0, - ops.LOAD_ATTR : 0, - ops.STORE_ATTR : -2, - ops.DELETE_ATTR : -1, + ops.LOAD_ATTR: 0, + ops.STORE_ATTR: -2, + ops.DELETE_ATTR: -1, - ops.LOAD_GLOBAL : 1, - ops.STORE_GLOBAL : -1, - ops.DELETE_GLOBAL : 0, - ops.DELETE_DEREF : 0, - - ops.LOAD_CLOSURE : 1, - ops.LOAD_DEREF : 1, - ops.STORE_DEREF : -1, + ops.LOAD_GLOBAL: 1, + ops.STORE_GLOBAL: -1, + ops.DELETE_GLOBAL: 0, ops.DELETE_DEREF: 0, - ops.LOAD_CONST : 1, + ops.LOAD_CLOSURE: 1, + ops.LOAD_DEREF: 1, + ops.STORE_DEREF: -1, + ops.DELETE_DEREF: 0, - ops.IMPORT_STAR : -1, - ops.IMPORT_NAME : -1, - ops.IMPORT_FROM : 1, + ops.LOAD_CONST: 1, - ops.JUMP_FORWARD : 0, - ops.JUMP_ABSOLUTE : 0, - ops.JUMP_IF_TRUE_OR_POP : 0, - ops.JUMP_IF_FALSE_OR_POP : 0, - ops.POP_JUMP_IF_TRUE : -1, - ops.POP_JUMP_IF_FALSE : -1, - ops.JUMP_IF_NOT_DEBUG : 0, + ops.IMPORT_STAR: -1, + ops.IMPORT_NAME: -1, + ops.IMPORT_FROM: 1, + + ops.JUMP_FORWARD: 0, + ops.JUMP_ABSOLUTE: 0, + ops.JUMP_IF_TRUE_OR_POP: 0, + ops.JUMP_IF_FALSE_OR_POP: 0, + ops.POP_JUMP_IF_TRUE: -1, + ops.POP_JUMP_IF_FALSE: -1, + ops.JUMP_IF_NOT_DEBUG: 0, ops.BUILD_LIST_FROM_ARG: 1, } diff --git a/pypy/interpreter/astcompiler/misc.py b/pypy/interpreter/astcompiler/misc.py --- a/pypy/interpreter/astcompiler/misc.py +++ b/pypy/interpreter/astcompiler/misc.py @@ -108,6 +108,15 @@ return "_%s%s" % (klass[i:], name) +def intern_if_common_string(space, w_const): + # only intern identifier-like strings + from pypy.objspace.std.unicodeobject import _isidentifier + if (space.is_w(space.type(w_const), space.w_unicode) and + _isidentifier(space.unicode_w(w_const))): + return space.new_interned_w_str(w_const) + return w_const + + def new_identifier(space, name): # Check whether there are non-ASCII characters in the identifier; if # so, normalize to NFKC diff --git a/pypy/interpreter/astcompiler/optimize.py b/pypy/interpreter/astcompiler/optimize.py --- a/pypy/interpreter/astcompiler/optimize.py +++ b/pypy/interpreter/astcompiler/optimize.py @@ -279,6 +279,11 @@ if w_const is None: return tup consts_w[i] = w_const + # intern the string constants packed into the tuple here, + # because assemble.py will see the result as just a tuple constant + for i in range(len(consts_w)): + consts_w[i] = misc.intern_if_common_string( + self.space, consts_w[i]) else: consts_w = [] w_consts = self.space.newtuple(consts_w) diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py --- a/pypy/interpreter/baseobjspace.py +++ b/pypy/interpreter/baseobjspace.py @@ -15,7 +15,7 @@ UserDelAction) from pypy.interpreter.error import OperationError, new_exception_class, oefmt from pypy.interpreter.argument import Arguments -from pypy.interpreter.miscutils import ThreadLocals +from pypy.interpreter.miscutils import ThreadLocals, make_weak_value_dictionary __all__ = ['ObjSpace', 'OperationError', 'W_Root'] @@ -362,7 +362,7 @@ self.builtin_modules = {} self.reloading_modules = {} - self.interned_strings = {} + self.interned_strings = make_weak_value_dictionary(self, unicode, W_Root) self.actionflag = ActionFlag() # changed by the signal module self.check_signal_action = None # changed by the signal module self.user_del_action = UserDelAction(self) @@ -501,11 +501,6 @@ if name not in modules: modules.append(name) - # a bit of custom logic: rctime take precedence over time - # XXX this could probably be done as a "requires" in the config - if 'rctime' in modules and 'time' in modules: - modules.remove('time') - self._builtinmodule_list = modules return self._builtinmodule_list @@ -772,26 +767,35 @@ else: return self.w_False - def new_interned_w_str(self, w_s): - s = self.str_w(w_s) + def new_interned_w_str(self, w_u): + assert isinstance(w_u, W_Root) # and is not None + u = self.unicode_w(w_u) + if not we_are_translated(): + assert type(u) is unicode + w_u1 = self.interned_strings.get(u) + if w_u1 is None: + w_u1 = w_u + self.interned_strings.set(u, w_u1) + return w_u1 + + def new_interned_str(self, s): + """Assumes an identifier (utf-8 encoded str)""" if not we_are_translated(): assert type(s) is str - try: - return self.interned_strings[s] - except KeyError: - pass - self.interned_strings[s] = w_s - return w_s + u = s.decode('utf-8') + w_s1 = self.interned_strings.get(u) + if w_s1 is None: + w_s1 = self.wrap(u) + self.interned_strings.set(u, w_s1) + return w_s1 - def new_interned_str(self, s): + def is_interned_str(self, s): + """Assumes an identifier (utf-8 encoded str)""" + # interface for marshal_impl if not we_are_translated(): assert type(s) is str - try: - return self.interned_strings[s] - except KeyError: - pass - w_s = self.interned_strings[s] = self.wrap(s) - return w_s + u = s.decode('utf-8') + return self.interned_strings.get(u) is not None def descr_self_interp_w(self, RequiredClass, w_obj): if not isinstance(w_obj, RequiredClass): diff --git a/pypy/interpreter/executioncontext.py b/pypy/interpreter/executioncontext.py --- a/pypy/interpreter/executioncontext.py +++ b/pypy/interpreter/executioncontext.py @@ -32,6 +32,17 @@ self.compiler = space.createcompiler() self.profilefunc = None self.w_profilefuncarg = None + self.thread_disappeared = False # might be set to True after os.fork() + + @staticmethod + def _mark_thread_disappeared(space): + # Called in the child process after os.fork() by interp_posix.py. + # Marks all ExecutionContexts except the current one + # with 'thread_disappeared = True'. + me = space.getexecutioncontext() + for ec in space.threadlocals.getallvalues().values(): + if ec is not me: + ec.thread_disappeared = True def gettopframe(self): return self.topframeref() diff --git a/pypy/interpreter/miscutils.py b/pypy/interpreter/miscutils.py --- a/pypy/interpreter/miscutils.py +++ b/pypy/interpreter/miscutils.py @@ -31,3 +31,19 @@ def getallvalues(self): return {0: self._value} + + +def make_weak_value_dictionary(space, keytype, valuetype): + "NOT_RPYTHON" + if space.config.translation.rweakref: + from rpython.rlib.rweakref import RWeakValueDictionary + return RWeakValueDictionary(keytype, valuetype) + else: + class FakeWeakValueDict(object): + def __init__(self): + self._dict = {} + def get(self, key): + return self._dict.get(key, None) + def set(self, key, value): + self._dict[key] = value + return FakeWeakValueDict() diff --git a/pypy/interpreter/pyframe.py b/pypy/interpreter/pyframe.py --- a/pypy/interpreter/pyframe.py +++ b/pypy/interpreter/pyframe.py @@ -131,7 +131,6 @@ # class bodies only have CO_NEWLOCALS. # CO_NEWLOCALS: make a locals dict unless optimized is also set # CO_OPTIMIZED: no locals dict needed at all - # NB: this method is overridden in nestedscope.py flags = code.co_flags if not (flags & pycode.CO_OPTIMIZED): if flags & pycode.CO_NEWLOCALS: diff --git a/pypy/interpreter/test/test_compiler.py b/pypy/interpreter/test/test_compiler.py --- a/pypy/interpreter/test/test_compiler.py +++ b/pypy/interpreter/test/test_compiler.py @@ -1121,7 +1121,13 @@ sys.stdout = out output = s.getvalue() assert "CALL_METHOD" in output - + + def test_interned_strings(self): + source = """x = ('foo_bar42', 5); y = 'foo_bar42'; z = x[0]""" + ns = {} + exec(source, ns) + assert ns['y'] is ns['z'] + class AppTestExceptions: def test_indentation_error(self): diff --git a/pypy/interpreter/test/test_objspace.py b/pypy/interpreter/test/test_objspace.py --- a/pypy/interpreter/test/test_objspace.py +++ b/pypy/interpreter/test/test_objspace.py @@ -378,3 +378,41 @@ assert space.str_w(space.getattr(space.sys, w_executable)) == 'foobar' space.startup() assert space.str_w(space.getattr(space.sys, w_executable)) == 'foobar' + + def test_interned_strings_are_weak(self): + import weakref, gc, random + space = self.space + assert space.config.translation.rweakref + w1 = space.new_interned_str("abcdef") + w2 = space.new_interned_str("abcdef") + assert w2 is w1 + # + # check that 'w1' goes away if we don't hold a reference to it + rw1 = weakref.ref(w1) + del w1, w2 + i = 10 + while rw1() is not None: + i -= 1 + assert i >= 0 + gc.collect() + # + s = "foobar%r" % random.random() + w0 = space.wrap(s) + w1 = space.new_interned_w_str(w0) + assert w1 is w0 + w2 = space.new_interned_w_str(w0) + assert w2 is w0 + w3 = space.wrap(s) + assert w3 is not w0 + w4 = space.new_interned_w_str(w3) + assert w4 is w0 + # + # check that 'w0' goes away if we don't hold a reference to it + # (even if we hold a reference to 'w3') + rw0 = weakref.ref(w0) + del w0, w1, w2, w4 + i = 10 + while rw0() is not None: + i -= 1 + assert i >= 0 + gc.collect() diff --git a/pypy/module/_cffi_backend/ctypeprim.py b/pypy/module/_cffi_backend/ctypeprim.py --- a/pypy/module/_cffi_backend/ctypeprim.py +++ b/pypy/module/_cffi_backend/ctypeprim.py @@ -158,21 +158,14 @@ class W_CTypePrimitiveSigned(W_CTypePrimitive): - _attrs_ = ['value_fits_long', 'vmin', 'vrangemax'] - _immutable_fields_ = ['value_fits_long', 'vmin', 'vrangemax'] + _attrs_ = ['value_fits_long', 'value_smaller_than_long'] + _immutable_fields_ = ['value_fits_long', 'value_smaller_than_long'] is_primitive_integer = True def __init__(self, *args): W_CTypePrimitive.__init__(self, *args) self.value_fits_long = self.size <= rffi.sizeof(lltype.Signed) - if self.size < rffi.sizeof(lltype.Signed): - assert self.value_fits_long - sh = self.size * 8 - self.vmin = r_uint(-1) << (sh - 1) - self.vrangemax = (r_uint(1) << sh) - 1 - else: - self.vmin = r_uint(0) - self.vrangemax = r_uint(-1) + self.value_smaller_than_long = self.size < rffi.sizeof(lltype.Signed) def cast_to_int(self, cdata): return self.convert_to_object(cdata) @@ -192,8 +185,17 @@ def convert_from_object(self, cdata, w_ob): if self.value_fits_long: value = misc.as_long(self.space, w_ob) - if self.size < rffi.sizeof(lltype.Signed): - if r_uint(value) - self.vmin > self.vrangemax: + if self.value_smaller_than_long: + size = self.size + if size == 1: + signextended = misc.signext(value, 1) + elif size == 2: + signextended = misc.signext(value, 2) + elif size == 4: + signextended = misc.signext(value, 4) + else: + raise AssertionError("unsupported size") + if value != signextended: self._overflow(w_ob) misc.write_raw_signed_data(cdata, value, self.size) else: @@ -221,7 +223,7 @@ length = w_cdata.get_array_length() populate_list_from_raw_array(res, buf, length) return res - elif self.value_fits_long: + elif self.value_smaller_than_long: res = [0] * w_cdata.get_array_length() misc.unpack_list_from_raw_array(res, w_cdata._cdata, self.size) return res @@ -235,8 +237,8 @@ cdata = rffi.cast(rffi.LONGP, cdata) copy_list_to_raw_array(int_list, cdata) else: - overflowed = misc.pack_list_to_raw_array_bounds( - int_list, cdata, self.size, self.vmin, self.vrangemax) + overflowed = misc.pack_list_to_raw_array_bounds_signed( + int_list, cdata, self.size) if overflowed != 0: self._overflow(self.space.wrap(overflowed)) return True @@ -314,8 +316,8 @@ def pack_list_of_items(self, cdata, w_ob): int_list = self.space.listview_int(w_ob) if int_list is not None: - overflowed = misc.pack_list_to_raw_array_bounds( - int_list, cdata, self.size, r_uint(0), self.vrangemax) + overflowed = misc.pack_list_to_raw_array_bounds_unsigned( + int_list, cdata, self.size, self.vrangemax) if overflowed != 0: self._overflow(self.space.wrap(overflowed)) return True diff --git a/pypy/module/_cffi_backend/misc.py b/pypy/module/_cffi_backend/misc.py --- a/pypy/module/_cffi_backend/misc.py +++ b/pypy/module/_cffi_backend/misc.py @@ -222,6 +222,19 @@ neg_msg = "can't convert negative number to unsigned" ovf_msg = "long too big to convert" +@specialize.arg(1) +def signext(value, size): + # 'value' is sign-extended from 'size' bytes to a full integer. + # 'size' should be a constant smaller than a full integer size. + if size == rffi.sizeof(rffi.SIGNEDCHAR): + return rffi.cast(lltype.Signed, rffi.cast(rffi.SIGNEDCHAR, value)) + elif size == rffi.sizeof(rffi.SHORT): + return rffi.cast(lltype.Signed, rffi.cast(rffi.SHORT, value)) + elif size == rffi.sizeof(rffi.INT): + return rffi.cast(lltype.Signed, rffi.cast(rffi.INT, value)) + else: + raise AssertionError("unsupported size") + # ____________________________________________________________ class _NotStandardObject(Exception): @@ -339,13 +352,26 @@ # ____________________________________________________________ -def pack_list_to_raw_array_bounds(int_list, target, size, vmin, vrangemax): +def pack_list_to_raw_array_bounds_signed(int_list, target, size): for TP, TPP in _prim_signed_types: if size == rffi.sizeof(TP): ptr = rffi.cast(TPP, target) for i in range(len(int_list)): x = int_list[i] - if r_uint(x) - vmin > vrangemax: + y = rffi.cast(TP, x) + if x != rffi.cast(lltype.Signed, y): + return x # overflow + ptr[i] = y + return 0 + raise NotImplementedError("bad integer size") + +def pack_list_to_raw_array_bounds_unsigned(int_list, target, size, vrangemax): + for TP, TPP in _prim_signed_types: + if size == rffi.sizeof(TP): + ptr = rffi.cast(TPP, target) + for i in range(len(int_list)): + x = int_list[i] + if r_uint(x) > vrangemax: return x # overflow ptr[i] = rffi.cast(TP, x) return 0 diff --git a/pypy/module/_codecs/locale_codec.h b/pypy/module/_codecs/locale_codec.h --- a/pypy/module/_codecs/locale_codec.h +++ b/pypy/module/_codecs/locale_codec.h @@ -2,7 +2,7 @@ #include <wchar.h> #include "src/precommondefs.h" -RPY_EXPORTED_FOR_TESTS wchar_t* pypy_char2wchar(const char* arg, size_t *size); -RPY_EXPORTED_FOR_TESTS void pypy_char2wchar_free(wchar_t *text); -RPY_EXPORTED_FOR_TESTS char* pypy_wchar2char(const wchar_t *text, size_t *error_pos); -RPY_EXPORTED_FOR_TESTS void pypy_wchar2char_free(char *bytes); +RPY_EXTERN wchar_t* pypy_char2wchar(const char* arg, size_t *size); +RPY_EXTERN void pypy_char2wchar_free(wchar_t *text); +RPY_EXTERN char* pypy_wchar2char(const wchar_t *text, size_t *error_pos); +RPY_EXTERN void pypy_wchar2char_free(char *bytes); diff --git a/pypy/module/_lsprof/test/test_cprofile.py b/pypy/module/_lsprof/test/test_cprofile.py --- a/pypy/module/_lsprof/test/test_cprofile.py +++ b/pypy/module/_lsprof/test/test_cprofile.py @@ -1,6 +1,6 @@ class AppTestCProfile(object): spaceconfig = { - "usemodules": ['_lsprof', 'rctime'], + "usemodules": ['_lsprof', 'time'], } def setup_class(cls): diff --git a/pypy/module/_md5/test/test_md5.py b/pypy/module/_md5/test/test_md5.py --- a/pypy/module/_md5/test/test_md5.py +++ b/pypy/module/_md5/test/test_md5.py @@ -7,7 +7,7 @@ class AppTestMD5(object): spaceconfig = { - 'usemodules': ['_md5', 'binascii', 'rctime', 'struct'], + 'usemodules': ['_md5', 'binascii', 'time', 'struct'], } def setup_class(cls): diff --git a/pypy/module/_multibytecodec/src/cjkcodecs/multibytecodec.h b/pypy/module/_multibytecodec/src/cjkcodecs/multibytecodec.h --- a/pypy/module/_multibytecodec/src/cjkcodecs/multibytecodec.h +++ b/pypy/module/_multibytecodec/src/cjkcodecs/multibytecodec.h @@ -97,24 +97,24 @@ Py_UNICODE *outbuf_start, *outbuf, *outbuf_end; }; -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN struct pypy_cjk_dec_s *pypy_cjk_dec_new(const MultibyteCodec *codec); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_ssize_t pypy_cjk_dec_init(struct pypy_cjk_dec_s *d, char *inbuf, Py_ssize_t inlen); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN void pypy_cjk_dec_free(struct pypy_cjk_dec_s *); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_ssize_t pypy_cjk_dec_chunk(struct pypy_cjk_dec_s *); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_UNICODE *pypy_cjk_dec_outbuf(struct pypy_cjk_dec_s *); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_ssize_t pypy_cjk_dec_outlen(struct pypy_cjk_dec_s *); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_ssize_t pypy_cjk_dec_inbuf_remaining(struct pypy_cjk_dec_s *d); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_ssize_t pypy_cjk_dec_inbuf_consumed(struct pypy_cjk_dec_s* d); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_ssize_t pypy_cjk_dec_replace_on_error(struct pypy_cjk_dec_s* d, Py_UNICODE *, Py_ssize_t, Py_ssize_t); @@ -125,35 +125,35 @@ unsigned char *outbuf_start, *outbuf, *outbuf_end; }; -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN struct pypy_cjk_enc_s *pypy_cjk_enc_new(const MultibyteCodec *codec); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_ssize_t pypy_cjk_enc_init(struct pypy_cjk_enc_s *d, Py_UNICODE *inbuf, Py_ssize_t inlen); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN void pypy_cjk_enc_free(struct pypy_cjk_enc_s *); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_ssize_t pypy_cjk_enc_chunk(struct pypy_cjk_enc_s *, Py_ssize_t); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_ssize_t pypy_cjk_enc_reset(struct pypy_cjk_enc_s *); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN char *pypy_cjk_enc_outbuf(struct pypy_cjk_enc_s *); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_ssize_t pypy_cjk_enc_outlen(struct pypy_cjk_enc_s *); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_ssize_t pypy_cjk_enc_inbuf_remaining(struct pypy_cjk_enc_s *d); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_ssize_t pypy_cjk_enc_inbuf_consumed(struct pypy_cjk_enc_s* d); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN Py_ssize_t pypy_cjk_enc_replace_on_error(struct pypy_cjk_enc_s* d, char *, Py_ssize_t, Py_ssize_t); -RPY_EXPORTED_FOR_TESTS +RPY_EXTERN const MultibyteCodec *pypy_cjk_enc_getcodec(struct pypy_cjk_enc_s *); /* list of codecs defined in the .c files */ #define DEFINE_CODEC(name) \ - RPY_EXPORTED_FOR_TESTS MultibyteCodec *pypy_cjkcodec_##name(void); + RPY_EXTERN MultibyteCodec *pypy_cjkcodec_##name(void); // _codecs_cn DEFINE_CODEC(gb2312) diff --git a/pypy/module/_multiprocessing/interp_semaphore.py b/pypy/module/_multiprocessing/interp_semaphore.py --- a/pypy/module/_multiprocessing/interp_semaphore.py +++ b/pypy/module/_multiprocessing/interp_semaphore.py @@ -254,7 +254,7 @@ start = _GetTickCount() while True: - from pypy.module.rctime.interp_time import State + from pypy.module.time.interp_time import State interrupt_event = space.fromcache(State).get_interrupt_event() handles = [self.handle, interrupt_event] diff --git a/pypy/module/_posixsubprocess/_posixsubprocess.h b/pypy/module/_posixsubprocess/_posixsubprocess.h --- a/pypy/module/_posixsubprocess/_posixsubprocess.h +++ b/pypy/module/_posixsubprocess/_posixsubprocess.h @@ -1,6 +1,6 @@ #include "src/precommondefs.h" -RPY_EXPORTED_FOR_TESTS void +RPY_EXTERN void pypy_subprocess_child_exec( char *const exec_array[], char *const argv[], @@ -17,8 +17,8 @@ int (*preexec_fn)(void*), void *preexec_fn_arg); -RPY_EXPORTED_FOR_TESTS int +RPY_EXTERN int pypy_subprocess_cloexec_pipe(int *fds); -RPY_EXPORTED_FOR_TESTS void +RPY_EXTERN void pypy_subprocess_init(void); diff --git a/pypy/module/_random/test/test_random.py b/pypy/module/_random/test/test_random.py --- a/pypy/module/_random/test/test_random.py +++ b/pypy/module/_random/test/test_random.py @@ -1,6 +1,6 @@ class AppTestRandom: spaceconfig = { - "usemodules": ['_random', 'rctime'], + "usemodules": ['_random', 'time'], } def test_dict(self): diff --git a/pypy/module/_ssl/interp_ssl.py b/pypy/module/_ssl/interp_ssl.py --- a/pypy/module/_ssl/interp_ssl.py +++ b/pypy/module/_ssl/interp_ssl.py @@ -685,7 +685,8 @@ raise _ssl_seterror(space, self, length) try: # this is actually an immutable bytes sequence - return space.wrap(rffi.charpsize2str(buf_ptr[0], length)) + return space.wrapbytes( + rffi.charpsize2str(buf_ptr[0], length)) finally: libssl_OPENSSL_free(buf_ptr[0]) else: diff --git a/pypy/module/_ssl/test/test_ssl.py b/pypy/module/_ssl/test/test_ssl.py --- a/pypy/module/_ssl/test/test_ssl.py +++ b/pypy/module/_ssl/test/test_ssl.py @@ -181,6 +181,14 @@ self.s.close() del ss; gc.collect() + def test_peer_certificate(self): + import gc, ssl + ss = ssl.wrap_socket(self.s) + assert ss.getpeercert() == {} + assert type(ss.getpeercert(True)) is bytes + self.s.close() + del ss; gc.collect() + def test_npn_protocol(self): import socket, _ssl, gc ctx = _ssl._SSLContext() diff --git a/pypy/module/_ssl/thread_lock.py b/pypy/module/_ssl/thread_lock.py --- a/pypy/module/_ssl/thread_lock.py +++ b/pypy/module/_ssl/thread_lock.py @@ -24,12 +24,19 @@ separate_module_source = """ #include <openssl/crypto.h> +#ifndef _WIN32 +# include <pthread.h> +#endif static unsigned int _ssl_locks_count = 0; static struct RPyOpaque_ThreadLock *_ssl_locks; static unsigned long _ssl_thread_id_function(void) { - return RPyThreadGetIdent(); +#ifdef _WIN32 + return (unsigned long)GetCurrentThreadId(); +#else + return (unsigned long)pthread_self(); +#endif } static void _ssl_thread_locking_function(int mode, int n, const char *file, @@ -65,7 +72,7 @@ eci = rthread.eci.merge(ExternalCompilationInfo( separate_module_sources=[separate_module_source], post_include_bits=[ - "RPY_EXPORTED_FOR_TESTS int _PyPy_SSL_SetupThreads(void);"], + "RPY_EXTERN int _PyPy_SSL_SetupThreads(void);"], libraries = libraries, )) diff --git a/pypy/module/bz2/test/test_bz2_file.py b/pypy/module/bz2/test/test_bz2_file.py --- a/pypy/module/bz2/test/test_bz2_file.py +++ b/pypy/module/bz2/test/test_bz2_file.py @@ -54,7 +54,7 @@ # XXX: CheckAllocation fails on py3 (seems to false positive on # BZ2File's RLocks) spaceconfig = { - 'usemodules': ['bz2', 'binascii', 'rctime', 'struct', 'thread'] + 'usemodules': ['bz2', 'binascii', 'time', 'struct', 'thread'] } def setup_class(cls): diff --git a/pypy/module/cppyy/include/capi.h b/pypy/module/cppyy/include/capi.h --- a/pypy/module/cppyy/include/capi.h +++ b/pypy/module/cppyy/include/capi.h @@ -2,6 +2,7 @@ #define CPPYY_CAPI #include <stddef.h> +#include "src/precommondefs.h" #ifdef __cplusplus extern "C" { @@ -15,102 +16,167 @@ typedef void* (*cppyy_methptrgetter_t)(cppyy_object_t); /* name to opaque C++ scope representation -------------------------------- */ + RPY_EXTERN int cppyy_num_scopes(cppyy_scope_t parent); + RPY_EXTERN char* cppyy_scope_name(cppyy_scope_t parent, int iscope); + RPY_EXTERN char* cppyy_resolve_name(const char* cppitem_name); + RPY_EXTERN cppyy_scope_t cppyy_get_scope(const char* scope_name); + RPY_EXTERN cppyy_type_t cppyy_get_template(const char* template_name); + RPY_EXTERN cppyy_type_t cppyy_actual_class(cppyy_type_t klass, cppyy_object_t obj); /* memory management ------------------------------------------------------ */ + RPY_EXTERN cppyy_object_t cppyy_allocate(cppyy_type_t type); + RPY_EXTERN void cppyy_deallocate(cppyy_type_t type, cppyy_object_t self); + RPY_EXTERN void cppyy_destruct(cppyy_type_t type, cppyy_object_t self); /* method/function dispatching -------------------------------------------- */ + RPY_EXTERN void cppyy_call_v(cppyy_method_t method, cppyy_object_t self, int nargs, void* args); + RPY_EXTERN unsigned char cppyy_call_b(cppyy_method_t method, cppyy_object_t self, int nargs, void* args); + RPY_EXTERN char cppyy_call_c(cppyy_method_t method, cppyy_object_t self, int nargs, void* args); + RPY_EXTERN short cppyy_call_h(cppyy_method_t method, cppyy_object_t self, int nargs, void* args); + RPY_EXTERN int cppyy_call_i(cppyy_method_t method, cppyy_object_t self, int nargs, void* args); + RPY_EXTERN long cppyy_call_l(cppyy_method_t method, cppyy_object_t self, int nargs, void* args); + RPY_EXTERN long long cppyy_call_ll(cppyy_method_t method, cppyy_object_t self, int nargs, void* args); + RPY_EXTERN float cppyy_call_f(cppyy_method_t method, cppyy_object_t self, int nargs, void* args); + RPY_EXTERN double cppyy_call_d(cppyy_method_t method, cppyy_object_t self, int nargs, void* args); + RPY_EXTERN void* cppyy_call_r(cppyy_method_t method, cppyy_object_t self, int nargs, void* args); + RPY_EXTERN char* cppyy_call_s(cppyy_method_t method, cppyy_object_t self, int nargs, void* args); + RPY_EXTERN cppyy_object_t cppyy_constructor(cppyy_method_t method, cppyy_type_t klass, int nargs, void* args); + RPY_EXTERN cppyy_object_t cppyy_call_o(cppyy_method_t method, cppyy_object_t self, int nargs, void* args, cppyy_type_t result_type); + RPY_EXTERN cppyy_methptrgetter_t cppyy_get_methptr_getter(cppyy_scope_t scope, cppyy_index_t idx); /* handling of function argument buffer ----------------------------------- */ + RPY_EXTERN void* cppyy_allocate_function_args(int nargs); + RPY_EXTERN void cppyy_deallocate_function_args(void* args); + RPY_EXTERN size_t cppyy_function_arg_sizeof(); + RPY_EXTERN size_t cppyy_function_arg_typeoffset(); /* scope reflection information ------------------------------------------- */ + RPY_EXTERN int cppyy_is_namespace(cppyy_scope_t scope); + RPY_EXTERN int cppyy_is_enum(const char* type_name); /* class reflection information ------------------------------------------- */ + RPY_EXTERN char* cppyy_final_name(cppyy_type_t type); + RPY_EXTERN char* cppyy_scoped_final_name(cppyy_type_t type); + RPY_EXTERN int cppyy_has_complex_hierarchy(cppyy_type_t type); + RPY_EXTERN int cppyy_num_bases(cppyy_type_t type); + RPY_EXTERN char* cppyy_base_name(cppyy_type_t type, int base_index); + RPY_EXTERN int cppyy_is_subtype(cppyy_type_t derived, cppyy_type_t base); /* calculate offsets between declared and actual type, up-cast: direction > 0; down-cast: direction < 0 */ + RPY_EXTERN ptrdiff_t cppyy_base_offset(cppyy_type_t derived, cppyy_type_t base, cppyy_object_t address, int direction); /* method/function reflection information --------------------------------- */ + RPY_EXTERN int cppyy_num_methods(cppyy_scope_t scope); + RPY_EXTERN cppyy_index_t cppyy_method_index_at(cppyy_scope_t scope, int imeth); + RPY_EXTERN cppyy_index_t* cppyy_method_indices_from_name(cppyy_scope_t scope, const char* name); + RPY_EXTERN char* cppyy_method_name(cppyy_scope_t scope, cppyy_index_t idx); + RPY_EXTERN char* cppyy_method_result_type(cppyy_scope_t scope, cppyy_index_t idx); + RPY_EXTERN int cppyy_method_num_args(cppyy_scope_t scope, cppyy_index_t idx); + RPY_EXTERN int cppyy_method_req_args(cppyy_scope_t scope, cppyy_index_t idx); + RPY_EXTERN char* cppyy_method_arg_type(cppyy_scope_t scope, cppyy_index_t idx, int arg_index); + RPY_EXTERN char* cppyy_method_arg_default(cppyy_scope_t scope, cppyy_index_t idx, int arg_index); + RPY_EXTERN char* cppyy_method_signature(cppyy_scope_t scope, cppyy_index_t idx); + RPY_EXTERN int cppyy_method_is_template(cppyy_scope_t scope, cppyy_index_t idx); + RPY_EXTERN int cppyy_method_num_template_args(cppyy_scope_t scope, cppyy_index_t idx); + RPY_EXTERN char* cppyy_method_template_arg_name(cppyy_scope_t scope, cppyy_index_t idx, cppyy_index_t iarg); + RPY_EXTERN cppyy_method_t cppyy_get_method(cppyy_scope_t scope, cppyy_index_t idx); + RPY_EXTERN cppyy_index_t cppyy_get_global_operator( cppyy_scope_t scope, cppyy_scope_t lc, cppyy_scope_t rc, const char* op); /* method properties ------------------------------------------------------ */ + RPY_EXTERN int cppyy_is_constructor(cppyy_type_t type, cppyy_index_t idx); + RPY_EXTERN int cppyy_is_staticmethod(cppyy_type_t type, cppyy_index_t idx); /* data member reflection information ------------------------------------- */ + RPY_EXTERN int cppyy_num_datamembers(cppyy_scope_t scope); + RPY_EXTERN char* cppyy_datamember_name(cppyy_scope_t scope, int datamember_index); + RPY_EXTERN char* cppyy_datamember_type(cppyy_scope_t scope, int datamember_index); + RPY_EXTERN ptrdiff_t cppyy_datamember_offset(cppyy_scope_t scope, int datamember_index); + RPY_EXTERN int cppyy_datamember_index(cppyy_scope_t scope, const char* name); /* data member properties ------------------------------------------------- */ + RPY_EXTERN int cppyy_is_publicdata(cppyy_type_t type, int datamember_index); + RPY_EXTERN int cppyy_is_staticdata(cppyy_type_t type, int datamember_index); /* misc helpers ----------------------------------------------------------- */ + RPY_EXTERN long long cppyy_strtoll(const char* str); + RPY_EXTERN unsigned long long cppyy_strtoull(const char* str); + RPY_EXTERN void cppyy_free(void* ptr); + RPY_EXTERN cppyy_object_t cppyy_charp2stdstring(const char* str); + RPY_EXTERN cppyy_object_t cppyy_stdstring2stdstring(cppyy_object_t ptr); #ifdef __cplusplus diff --git a/pypy/module/cppyy/src/dummy_backend.cxx b/pypy/module/cppyy/src/dummy_backend.cxx --- a/pypy/module/cppyy/src/dummy_backend.cxx +++ b/pypy/module/cppyy/src/dummy_backend.cxx @@ -1,4 +1,3 @@ -#include "src/precommondefs.h" #include "cppyy.h" #include "capi.h" @@ -349,29 +348,24 @@ /* name to opaque C++ scope representation -------------------------------- */ -RPY_EXPORTED_FOR_TESTS int cppyy_num_scopes(cppyy_scope_t handle) { return 0; } -RPY_EXPORTED_FOR_TESTS char* cppyy_resolve_name(const char* cppitem_name) { return cppstring_to_cstring(cppitem_name); } -RPY_EXPORTED_FOR_TESTS cppyy_scope_t cppyy_get_scope(const char* scope_name) { return s_handles[scope_name]; // lookup failure will return 0 (== error) } -RPY_EXPORTED_FOR_TESTS cppyy_type_t cppyy_actual_class(cppyy_type_t klass, cppyy_object_t /* obj */) { return klass; } /* memory management ------------------------------------------------------ */ -RPY_EXPORTED_FOR_TESTS void cppyy_destruct(cppyy_type_t handle, cppyy_object_t self) { if (handle == s_handles["example01"]) delete (dummy::example01*)self; @@ -379,7 +373,6 @@ /* method/function dispatching -------------------------------------------- */ -RPY_EXPORTED_FOR_TESTS void cppyy_call_v(cppyy_method_t method, cppyy_object_t self, int nargs, void* args) { long idx = (long)method; if (idx == s_methods["static_example01::staticSetPayload_payload*_double"]) { @@ -469,7 +462,6 @@ } } -RPY_EXPORTED_FOR_TESTS unsigned char cppyy_call_b(cppyy_method_t method, cppyy_object_t self, int nargs, void* args) { unsigned char result = 0; const long idx = (long)method; @@ -482,7 +474,6 @@ return result; } -RPY_EXPORTED_FOR_TESTS char cppyy_call_c(cppyy_method_t method, cppyy_object_t self, int nargs, void* args) { char result = 0; const long idx = (long)method; @@ -498,7 +489,6 @@ return result; } -RPY_EXPORTED_FOR_TESTS short cppyy_call_h(cppyy_method_t method, cppyy_object_t self, int nargs, void* args) { short result = 0; const long idx = (long)method; @@ -514,7 +504,6 @@ return result; } -RPY_EXPORTED_FOR_TESTS int cppyy_call_i(cppyy_method_t method, cppyy_object_t self, int nargs, void* args) { int result = 0; const long idx = (long)method; @@ -547,7 +536,6 @@ return result; } -RPY_EXPORTED_FOR_TESTS long cppyy_call_l(cppyy_method_t method, cppyy_object_t self, int nargs, void* args) { long result = 0; const long idx = (long)method; @@ -689,7 +677,6 @@ return result; } -RPY_EXPORTED_FOR_TESTS long long cppyy_call_ll(cppyy_method_t method, cppyy_object_t self, int nargs, void* args) { long long result = 0; const long idx = (long)method; @@ -705,7 +692,6 @@ return result; } -RPY_EXPORTED_FOR_TESTS float cppyy_call_f(cppyy_method_t method, cppyy_object_t self, int nargs, void* args) { float result = 0; const long idx = (long)method; @@ -718,7 +704,6 @@ return result; } -RPY_EXPORTED_FOR_TESTS double cppyy_call_d(cppyy_method_t method, cppyy_object_t self, int nargs, void* args) { double result = 0.; const long idx = (long)method; @@ -740,7 +725,6 @@ return result; } -RPY_EXPORTED_FOR_TESTS char* cppyy_call_s(cppyy_method_t method, cppyy_object_t self, int nargs, void* args) { char* result = 0; const long idx = (long)method; @@ -753,7 +737,6 @@ return result; } -RPY_EXPORTED_FOR_TESTS cppyy_object_t cppyy_constructor(cppyy_method_t method, cppyy_type_t handle, int nargs, void* args) { void* result = 0; const long idx = (long)method; @@ -776,14 +759,12 @@ return (cppyy_object_t)result; } -RPY_EXPORTED_FOR_TESTS cppyy_methptrgetter_t cppyy_get_methptr_getter(cppyy_type_t /* handle */, cppyy_index_t /* method_index */) { return (cppyy_methptrgetter_t)0; } /* handling of function argument buffer ----------------------------------- */ -RPY_EXPORTED_FOR_TESTS void* cppyy_allocate_function_args(int nargs) { CPPYY_G__value* args = (CPPYY_G__value*)malloc(nargs*sizeof(CPPYY_G__value)); for (int i = 0; i < nargs; ++i) @@ -793,36 +774,30 @@ /* handling of function argument buffer ----------------------------------- */ -RPY_EXPORTED_FOR_TESTS void cppyy_deallocate_function_args(void* args) { free(args); } -RPY_EXPORTED_FOR_TESTS size_t cppyy_function_arg_sizeof() { return sizeof(CPPYY_G__value); } -RPY_EXPORTED_FOR_TESTS size_t cppyy_function_arg_typeoffset() { return offsetof(CPPYY_G__value, type); } /* scope reflection information ------------------------------------------- */ -RPY_EXPORTED_FOR_TESTS int cppyy_is_namespace(cppyy_scope_t /* handle */) { return 0; } -RPY_EXPORTED_FOR_TESTS int cppyy_is_enum(const char* /* type_name */) { return 0; } /* class reflection information ------------------------------------------- */ -RPY_EXPORTED_FOR_TESTS char* cppyy_final_name(cppyy_type_t handle) { for (Handles_t::iterator isp = s_handles.begin(); isp != s_handles.end(); ++isp) { if (isp->second == handle) @@ -831,75 +806,61 @@ return cppstring_to_cstring("<unknown>"); } -RPY_EXPORTED_FOR_TESTS char* cppyy_scoped_final_name(cppyy_type_t handle) { return cppyy_final_name(handle); } -RPY_EXPORTED_FOR_TESTS int cppyy_has_complex_hierarchy(cppyy_type_t /* handle */) { return 0; } -RPY_EXPORTED_FOR_TESTS int cppyy_num_bases(cppyy_type_t /*handle*/) { return 0; } /* method/function reflection information --------------------------------- */ -RPY_EXPORTED_FOR_TESTS int cppyy_num_methods(cppyy_scope_t handle) { return s_scopes[handle].m_methods.size(); } -RPY_EXPORTED_FOR_TESTS cppyy_index_t cppyy_method_index_at(cppyy_scope_t /* scope */, int imeth) { return (cppyy_index_t)imeth; } -RPY_EXPORTED_FOR_TESTS char* cppyy_method_name(cppyy_scope_t handle, cppyy_index_t method_index) { return cppstring_to_cstring(s_scopes[handle].m_methods[(int)method_index].m_name); } -RPY_EXPORTED_FOR_TESTS char* cppyy_method_result_type(cppyy_scope_t handle, cppyy_index_t method_index) { return cppstring_to_cstring(s_scopes[handle].m_methods[method_index].m_returntype); } -RPY_EXPORTED_FOR_TESTS int cppyy_method_num_args(cppyy_scope_t handle, cppyy_index_t method_index) { return s_scopes[handle].m_methods[method_index].m_argtypes.size(); } -RPY_EXPORTED_FOR_TESTS int cppyy_method_req_args(cppyy_scope_t handle, cppyy_index_t method_index) { return cppyy_method_num_args(handle, method_index); } -RPY_EXPORTED_FOR_TESTS char* cppyy_method_arg_type(cppyy_scope_t handle, cppyy_index_t method_index, int arg_index) { return cppstring_to_cstring(s_scopes[handle].m_methods[method_index].m_argtypes[arg_index]); } -RPY_EXPORTED_FOR_TESTS char* cppyy_method_arg_default( cppyy_scope_t /* handle */, cppyy_index_t /* method_index */, int /* arg_index */) { return cppstring_to_cstring(""); } -RPY_EXPORTED_FOR_TESTS char* cppyy_method_signature(cppyy_scope_t /* handle */, cppyy_index_t /* method_index */) { return cppstring_to_cstring(""); } -RPY_EXPORTED_FOR_TESTS int cppyy_method_is_template(cppyy_scope_t /* handle */, cppyy_index_t /* method_index */) { return 0; } -RPY_EXPORTED_FOR_TESTS cppyy_method_t cppyy_get_method(cppyy_scope_t handle, cppyy_index_t method_index) { if (s_scopes.find(handle) != s_scopes.end()) { long id = s_scopes[handle].m_method_offset + (long)method_index; @@ -911,7 +872,6 @@ /* method properties ----------------------------------------------------- */ -RPY_EXPORTED_FOR_TESTS int cppyy_is_constructor(cppyy_type_t handle, cppyy_index_t method_index) { if (s_scopes.find(handle) != s_scopes.end()) return s_scopes[handle].m_methods[method_index].m_type == kConstructor; @@ -919,7 +879,6 @@ return 0; } -RPY_EXPORTED_FOR_TESTS int cppyy_is_staticmethod(cppyy_type_t handle, cppyy_index_t method_index) { if (s_scopes.find(handle) != s_scopes.end()) return s_scopes[handle].m_methods[method_index].m_type == kStatic; @@ -929,34 +888,28 @@ /* data member reflection information ------------------------------------- */ -RPY_EXPORTED_FOR_TESTS int cppyy_num_datamembers(cppyy_scope_t handle) { return s_scopes[handle].m_datambrs.size(); } -RPY_EXPORTED_FOR_TESTS char* cppyy_datamember_name(cppyy_scope_t handle, int idatambr) { return cppstring_to_cstring(s_scopes[handle].m_datambrs[idatambr].m_name); } -RPY_EXPORTED_FOR_TESTS char* cppyy_datamember_type(cppyy_scope_t handle, int idatambr) { return cppstring_to_cstring(s_scopes[handle].m_datambrs[idatambr].m_type); } -RPY_EXPORTED_FOR_TESTS ptrdiff_t cppyy_datamember_offset(cppyy_scope_t handle, int idatambr) { return s_scopes[handle].m_datambrs[idatambr].m_offset; } /* data member properties ------------------------------------------------ */ -RPY_EXPORTED_FOR_TESTS int cppyy_is_publicdata(cppyy_scope_t handle, int idatambr) { return 1; } -RPY_EXPORTED_FOR_TESTS int cppyy_is_staticdata(cppyy_scope_t handle, int idatambr) { return s_scopes[handle].m_datambrs[idatambr].m_isstatic; } @@ -964,44 +917,37 @@ /* misc helpers ----------------------------------------------------------- */ #if defined(_MSC_VER) -RPY_EXPORTED_FOR_TESTS long long cppyy_strtoll(const char* str) { return _strtoi64(str, NULL, 0); } extern "C" { -RPY_EXPORTED_FOR_TESTS unsigned long long cppyy_strtoull(const char* str) { return _strtoui64(str, NULL, 0); } } #else -RPY_EXPORTED_FOR_TESTS long long cppyy_strtoll(const char* str) { return strtoll(str, NULL, 0); } extern "C" { -RPY_EXPORTED_FOR_TESTS unsigned long long cppyy_strtoull(const char* str) { return strtoull(str, NULL, 0); } } #endif -RPY_EXPORTED_FOR_TESTS void cppyy_free(void* ptr) { free(ptr); } -RPY_EXPORTED_FOR_TESTS cppyy_object_t cppyy_charp2stdstring(const char* str) { void* arena = new char[sizeof(std::string)]; new (arena) std::string(str); return (cppyy_object_t)arena; } -RPY_EXPORTED_FOR_TESTS cppyy_object_t cppyy_stdstring2stdstring(cppyy_object_t ptr) { void* arena = new char[sizeof(std::string)]; new (arena) std::string(*(std::string*)ptr); diff --git a/pypy/module/cppyy/test/conftest.py b/pypy/module/cppyy/test/conftest.py --- a/pypy/module/cppyy/test/conftest.py +++ b/pypy/module/cppyy/test/conftest.py @@ -50,7 +50,7 @@ eci = ExternalCompilationInfo( separate_module_files=[srcpath.join('dummy_backend.cxx')], include_dirs=[incpath, tstpath, cdir], - compile_extra=['-DRPY_EXPORTED_FOR_TESTS=RPY_EXPORTED'], + compile_extra=['-DRPY_EXTERN=RPY_EXPORTED'], use_cpp_linker=True, ) diff --git a/pypy/module/cpyext/api.py b/pypy/module/cpyext/api.py --- a/pypy/module/cpyext/api.py +++ b/pypy/module/cpyext/api.py @@ -779,8 +779,7 @@ struct PyPyAPI { %(members)s } _pypyAPI; - RPY_EXPORTED_FOR_TESTS - struct PyPyAPI* pypyAPI = &_pypyAPI; + RPY_EXTERN struct PyPyAPI* pypyAPI = &_pypyAPI; """ % dict(members=structmembers) functions = generate_decls_and_callbacks(db, export_symbols) @@ -951,7 +950,7 @@ name_no_star = process_va_name(name) header = ('%s pypy_va_get_%s(va_list* vp)' % (name, name_no_star)) - pypy_decls.append('RPY_EXPORTED_FOR_TESTS ' + header + ';') + pypy_decls.append('RPY_EXTERN ' + header + ';') functions.append(header + '\n{return va_arg(*vp, %s);}\n' % name) for name, (typ, expr) in GLOBALS.iteritems(): @@ -1011,7 +1010,7 @@ if sys.platform == 'win32': get_pythonapi_source = ''' #include <windows.h> - RPY_EXPORTED_FOR_TESTS + RPY_EXTERN HANDLE pypy_get_pythonapi_handle() { MEMORY_BASIC_INFORMATION mi; memset(&mi, 0, sizeof(mi)); diff --git a/pypy/module/cpyext/include/modsupport.h b/pypy/module/cpyext/include/modsupport.h --- a/pypy/module/cpyext/include/modsupport.h +++ b/pypy/module/cpyext/include/modsupport.h @@ -82,11 +82,20 @@ /* * This is from pyport.h. Perhaps it belongs elsewhere. */ +#ifdef _WIN32 +/* explicitly export since PyAPI_FUNC is usually dllimport */ +#ifdef __cplusplus +#define PyMODINIT_FUNC extern "C" __declspec(dllexport) void +#else +#define PyMODINIT_FUNC __declspec(dllexport) void +#endif +#else #ifdef __cplusplus #define PyMODINIT_FUNC extern "C" PyAPI_FUNC(PyObject *) #else #define PyMODINIT_FUNC PyAPI_FUNC(PyObject *) #endif +#endif /* WIN32 */ PyAPI_DATA(char *) _Py_PackageContext; diff --git a/pypy/module/cpyext/src/pythread.c b/pypy/module/cpyext/src/pythread.c --- a/pypy/module/cpyext/src/pythread.c +++ b/pypy/module/cpyext/src/pythread.c @@ -1,11 +1,18 @@ #include <Python.h> +#ifndef _WIN32 +# include <pthread.h> +#endif #include "pythread.h" #include "src/thread.h" long PyThread_get_thread_ident(void) { - return RPyThreadGetIdent(); +#ifdef _WIN32 + return (long)GetCurrentThreadId(); +#else + return (long)pthread_self(); +#endif } PyThread_type_lock diff --git a/pypy/module/cpyext/test/conftest.py b/pypy/module/cpyext/test/conftest.py --- a/pypy/module/cpyext/test/conftest.py +++ b/pypy/module/cpyext/test/conftest.py @@ -7,7 +7,7 @@ # it's necessary to run "import time" at least once before any # other cpyext test, otherwise the same statement will fail in # test_datetime.py. - space = gettestobjspace(usemodules=['rctime']) + space = gettestobjspace(usemodules=['time']) space.getbuiltinmodule("time") def pytest_ignore_collect(path, config): diff --git a/pypy/module/cpyext/test/test_cpyext.py b/pypy/module/cpyext/test/test_cpyext.py --- a/pypy/module/cpyext/test/test_cpyext.py +++ b/pypy/module/cpyext/test/test_cpyext.py @@ -102,7 +102,7 @@ class LeakCheckingTest(object): """Base class for all cpyext tests.""" spaceconfig = dict(usemodules=['cpyext', 'thread', '_rawffi', 'array', - 'itertools', 'rctime', 'binascii', 'micronumpy']) + 'itertools', 'time', 'binascii', 'micronumpy']) spaceconfig['std.withmethodcache'] = True enable_leak_checking = True diff --git a/pypy/module/fcntl/test/test_fcntl.py b/pypy/module/fcntl/test/test_fcntl.py --- a/pypy/module/fcntl/test/test_fcntl.py +++ b/pypy/module/fcntl/test/test_fcntl.py @@ -12,7 +12,7 @@ class AppTestFcntl: spaceconfig = dict(usemodules=('fcntl', 'array', 'struct', 'termios', - 'select', 'rctime')) + 'select', 'time')) def setup_class(cls): tmpprefix = str(udir.ensure('test_fcntl', dir=1).join('tmp_')) diff --git a/pypy/module/imp/test/test_app.py b/pypy/module/imp/test/test_app.py --- a/pypy/module/imp/test/test_app.py +++ b/pypy/module/imp/test/test_app.py @@ -4,7 +4,7 @@ class AppTestImpModule: spaceconfig = { - 'usemodules': ['binascii', 'imp', 'itertools', 'rctime', 'struct'], + 'usemodules': ['binascii', 'imp', 'itertools', 'time', 'struct'], } def setup_class(cls): diff --git a/pypy/module/imp/test/test_import.py b/pypy/module/imp/test/test_import.py --- a/pypy/module/imp/test/test_import.py +++ b/pypy/module/imp/test/test_import.py @@ -163,7 +163,7 @@ class AppTestImport(BaseImportTest): spaceconfig = { - "usemodules": ['rctime'], + "usemodules": ['time'], } def setup_class(cls): @@ -1049,7 +1049,7 @@ class AppTestImportHooks(object): spaceconfig = { - "usemodules": ['struct', 'itertools', 'rctime'], + "usemodules": ['struct', 'itertools', 'time'], } def setup_class(cls): @@ -1266,7 +1266,7 @@ class AppTestMultithreadedImp(object): - spaceconfig = dict(usemodules=['thread', 'rctime']) + spaceconfig = dict(usemodules=['thread', 'time']) def setup_class(cls): #if not conftest.option.runappdirect: diff --git a/pypy/module/marshal/interp_marshal.py b/pypy/module/marshal/interp_marshal.py --- a/pypy/module/marshal/interp_marshal.py +++ b/pypy/module/marshal/interp_marshal.py @@ -152,7 +152,6 @@ atom_int(tc, int) puts code and int atom_int64(tc, int64) puts code and int64 atom_str(tc, str) puts code, len and string - atom_strlist(tc, strlist) puts code, len and list of strings building blocks for compound types: @@ -206,15 +205,6 @@ self.atom_int(typecode, len(x)) self.put(x) - def atom_strlist(self, typecode, tc2, x): - self.atom_int(typecode, len(x)) - atom_str = self.atom_str - for item in x: - # type(str) seems to be forbidden - #if type(item) is not str: _______________________________________________ pypy-commit mailing list pypy-commit@python.org https://mail.python.org/mailman/listinfo/pypy-commit
