CODE_FLAGS = dict(
CO_OPTIMIZED = 0x0001,
CO_NEWLOCALS = 0x0002,
CO_VARARGS = 0x0004,
CO_VARKEYWORDS = 0x0008,
CO_NESTED = 0x0010,
CO_GENERATOR = 0x0020,
)
ALL_CODE_FLAGS = unrolling_iterable(CODE_FLAGS.items())
PyFunctionObjectStruct = lltype.ForwardReference()
PyFunctionObject = lltype.Ptr(PyFunctionObjectStruct)
PyFunctionObjectFields = PyObjectFields + \
(("func_name", PyObject),)
cpython_struct("PyFunctionObject", PyFunctionObjectFields, PyFunctionObjectStruct)
PyCodeObjectStruct = lltype.ForwardReference()
PyCodeObject = lltype.Ptr(PyCodeObjectStruct)
PyCodeObjectFields = PyObjectFields + \
(("co_name", PyObject),
("co_flags", rffi.INT),
("co_argcount", rffi.INT),
)
cpython_struct("PyCodeObject", PyCodeObjectFields, PyCodeObjectStruct)
@bootstrap_function
def init_functionobject(space):
make_typedescr(Function.typedef,
basestruct=PyFunctionObject.TO,
attach=function_attach,
from rpython.rtyper.lltypesystem import rffi, lltype
from pypy.module.cpyext.pyobject import PyObject, make_ref
from pypy.module.cpyext.api import (cpython_api, CANNOT_FAIL, cpython_struct,
PyObjectFields)
from pypy.module.cpyext.import_ import PyImport_Import
from pypy.module.cpyext.typeobject import PyTypeObjectPtr
from pypy.interpreter.error import OperationError
from rpython.tool.sourcetools import func_renamer
# API import function
PyDateTime_CAPI = cpython_struct('PyDateTime_CAPI', (
('DateType', PyTypeObjectPtr),
('DateTimeType', PyTypeObjectPtr),
('TimeType', PyTypeObjectPtr),
('DeltaType', PyTypeObjectPtr),
))
@cpython_api([], lltype.Ptr(PyDateTime_CAPI))
def _PyDateTime_Import(space):
datetimeAPI = lltype.malloc(PyDateTime_CAPI,
flavor='raw',
track_allocation=False)
w_datetime = PyImport_Import(space, space.wrap("datetime"))
w_type = space.getattr(w_datetime, space.wrap("date"))
datetimeAPI.c_DateType = rffi.cast(PyTypeObjectPtr,
make_ref(space, w_type))
from pypy.module.cpyext.api import cpython_api, generic_cpy_call, CANNOT_FAIL, CConfig, cpython_struct
from pypy.rpython.lltypesystem import rffi, lltype
PyInterpreterState = lltype.Ptr(cpython_struct("PyInterpreterState", ()))
PyThreadState = lltype.Ptr(cpython_struct("PyThreadState", [("interp", PyInterpreterState)]))
@cpython_api([], PyThreadState, error=CANNOT_FAIL)
def PyEval_SaveThread(space):
"""Release the global interpreter lock (if it has been created and thread
support is enabled) and reset the thread state to NULL, returning the
previous thread state (which is not NULL except in PyPy). If the lock has been created,
the current thread must have acquired it. (This function is available even
when thread support is disabled at compile time.)"""
if rffi.aroundstate.before:
rffi.aroundstate.before()
return lltype.nullptr(PyThreadState.TO)
@cpython_api([PyThreadState], lltype.Void)
def PyEval_RestoreThread(space, tstate):
"""Acquire the global interpreter lock (if it has been created and thread
support is enabled) and set the thread state to tstate, which must not be
NULL. If the lock has been created, the current thread must not have
acquired it, otherwise deadlock ensues. (This function is available even
when thread support is disabled at compile time.)"""
if rffi.aroundstate.after:
rffi.aroundstate.after()
@cpython_api([], lltype.Void)
## objects. The buffer is then supposed to be immutable.
##
## - _PyString_Resize() works only on not-yet-pypy'd strings, and returns a
## similar object.
##
## - PyString_Size() doesn't need to force the object.
##
## - There could be an (expensive!) check in from_ref() that the buffer still
## corresponds to the pypy gc-managed string.
##
PyStringObjectStruct = lltype.ForwardReference()
PyStringObject = lltype.Ptr(PyStringObjectStruct)
PyStringObjectFields = PyObjectFields + \
(("buffer", rffi.CCHARP), ("size", Py_ssize_t))
cpython_struct("PyStringObject", PyStringObjectFields, PyStringObjectStruct)
@bootstrap_function
def init_stringobject(space):
"Type description of PyStringObject"
make_typedescr(space.w_str.instancetypedef,
basestruct=PyStringObject.TO,
attach=string_attach,
dealloc=string_dealloc,
realize=string_realize)
PyString_Check, PyString_CheckExact = build_type_checkers("String", "w_str")
def new_empty_str(space, length):
"""
Allocatse a PyStringObject and its buffer, but without a corresponding
bootstrap_function,
PyObject,
PyObjectFields,
CONST_STRING,
CANNOT_FAIL,
Py_ssize_t,
)
from pypy.module.cpyext.pyobject import make_typedescr, track_reference, from_ref
from rpython.rlib.rarithmetic import r_uint, intmask, LONG_TEST, r_ulonglong
from pypy.objspace.std.intobject import W_IntObject
import sys
PyIntObjectStruct = lltype.ForwardReference()
PyIntObject = lltype.Ptr(PyIntObjectStruct)
PyIntObjectFields = PyObjectFields + (("ob_ival", rffi.LONG),)
cpython_struct("PyIntObject", PyIntObjectFields, PyIntObjectStruct)
@bootstrap_function
def init_intobject(space):
"Type description of PyIntObject"
make_typedescr(space.w_int.layout.typedef, basestruct=PyIntObject.TO, attach=int_attach, realize=int_realize)
def int_attach(space, py_obj, w_obj):
"""
Fills a newly allocated PyIntObject with the given int object. The
value must not be modified.
"""
py_int = rffi.cast(PyIntObject, py_obj)
py_int.c_ob_ival = space.int_w(w_obj)
from rpython.rtyper.lltypesystem import lltype, rffi
from pypy.module.cpyext.api import (
cpython_api, cpython_struct, PyObject, build_type_checkers)
from pypy.module.cpyext.floatobject import PyFloat_AsDouble
from pypy.objspace.std.complexobject import W_ComplexObject
from pypy.interpreter.error import OperationError
PyComplex_Check, PyComplex_CheckExact = build_type_checkers("Complex")
Py_complex_t = lltype.ForwardReference()
Py_complex_ptr = lltype.Ptr(Py_complex_t)
Py_complex_fields = (("real", rffi.DOUBLE), ("imag", rffi.DOUBLE))
cpython_struct("Py_complex", Py_complex_fields, Py_complex_t)
@cpython_api([lltype.Float, lltype.Float], PyObject)
def PyComplex_FromDoubles(space, real, imag):
return space.newcomplex(real, imag)
@cpython_api([PyObject], lltype.Float, error=-1)
def PyComplex_RealAsDouble(space, w_obj):
if space.isinstance_w(w_obj, space.w_complex):
assert isinstance(w_obj, W_ComplexObject)
return w_obj.realval
else:
return space.float_w(w_obj)
@cpython_api([PyObject], lltype.Float, error=-1)
def PyComplex_ImagAsDouble(space, w_obj):
WARN_ABOUT_MISSING_SLOT_FUNCTIONS = False
PyType_Check, PyType_CheckExact = build_type_checkers("Type", "w_type")
PyHeapTypeObjectStruct = lltype.ForwardReference()
PyHeapTypeObject = lltype.Ptr(PyHeapTypeObjectStruct)
PyHeapTypeObjectFields = (
("ht_type", PyTypeObject),
("ht_name", PyObject),
("as_number", PyNumberMethods),
("as_mapping", PyMappingMethods),
("as_sequence", PySequenceMethods),
("as_buffer", PyBufferProcs),
)
cpython_struct("PyHeapTypeObject", PyHeapTypeObjectFields, PyHeapTypeObjectStruct,
level=2)
class W_GetSetPropertyEx(GetSetProperty):
def __init__(self, getset, w_type):
self.getset = getset
self.name = rffi.charp2str(getset.c_name)
self.w_type = w_type
doc = set = get = None
if doc:
doc = rffi.charp2str(getset.c_doc)
if getset.c_get:
get = GettersAndSetters.getter.im_func
if getset.c_set:
set = GettersAndSetters.setter.im_func
GetSetProperty.__init__(self, get, set, None, doc,
cls=None, use_closure=True,
WARN_ABOUT_MISSING_SLOT_FUNCTIONS = False
PyType_Check, PyType_CheckExact = build_type_checkers("Type", "w_type")
PyHeapTypeObjectStruct = lltype.ForwardReference()
PyHeapTypeObject = lltype.Ptr(PyHeapTypeObjectStruct)
PyHeapTypeObjectFields = (
("ht_type", PyTypeObject),
("ht_name", PyObject),
("as_number", PyNumberMethods),
("as_mapping", PyMappingMethods),
("as_sequence", PySequenceMethods),
("as_buffer", PyBufferProcs),
)
cpython_struct("PyHeapTypeObject", PyHeapTypeObjectFields, PyHeapTypeObjectStruct,
level=2)
class W_GetSetPropertyEx(GetSetProperty):
def __init__(self, getset, w_type):
self.getset = getset
self.name = rffi.charp2str(getset.c_name)
self.w_type = w_type
doc = set = get = None
if doc:
doc = rffi.charp2str(getset.c_doc)
if getset.c_get:
get = GettersAndSetters.getter.im_func
if getset.c_set:
set = GettersAndSetters.setter.im_func
GetSetProperty.__init__(self, get, set, None, doc,
cls=None, use_closure=True,
from pypy.rpython.lltypesystem import lltype, rffi
from pypy.module.cpyext.api import (cpython_api, cpython_struct, PyObject,
build_type_checkers)
from pypy.module.cpyext.floatobject import PyFloat_AsDouble
from pypy.objspace.std.complexobject import W_ComplexObject
from pypy.interpreter.error import OperationError
PyComplex_Check, PyComplex_CheckExact = build_type_checkers("Complex")
Py_complex_t = lltype.ForwardReference()
Py_complex_ptr = lltype.Ptr(Py_complex_t)
Py_complex_fields = (("real", rffi.DOUBLE), ("imag", rffi.DOUBLE))
cpython_struct("Py_complex", Py_complex_fields, Py_complex_t)
@cpython_api([lltype.Float, lltype.Float], PyObject)
def PyComplex_FromDoubles(space, real, imag):
return space.newcomplex(real, imag)
@cpython_api([PyObject], lltype.Float, error=-1)
def PyComplex_RealAsDouble(space, w_obj):
if space.is_true(space.isinstance(w_obj, space.w_complex)):
assert isinstance(w_obj, W_ComplexObject)
return w_obj.realval
else:
return space.float_w(w_obj)
@cpython_api([PyObject], lltype.Float, error=-1)
def PyComplex_ImagAsDouble(space, w_obj):
# API import function
PyDateTime_CAPI = cpython_struct(
'PyDateTime_CAPI',
(('DateType', PyTypeObjectPtr),
('DateTimeType', PyTypeObjectPtr),
('TimeType', PyTypeObjectPtr),
('DeltaType', PyTypeObjectPtr),
('TZInfoType', PyTypeObjectPtr),
('Date_FromDate', lltype.Ptr(lltype.FuncType(
[rffi.INT_real, rffi.INT_real, rffi.INT_real, PyTypeObjectPtr],
PyObject))),
('Time_FromTime', lltype.Ptr(lltype.FuncType(
[rffi.INT_real, rffi.INT_real, rffi.INT_real, rffi.INT_real,
PyObject, PyTypeObjectPtr],
PyObject))),
('DateTime_FromDateAndTime', lltype.Ptr(lltype.FuncType(
[rffi.INT_real, rffi.INT_real, rffi.INT_real,
rffi.INT_real, rffi.INT_real, rffi.INT_real, rffi.INT_real,
PyObject, PyTypeObjectPtr],
PyObject))),
('Delta_FromDelta', lltype.Ptr(lltype.FuncType(
[rffi.INT_real, rffi.INT_real, rffi.INT_real, rffi.INT_real,
PyTypeObjectPtr],
PyObject))),
))
@cpython_api([], lltype.Ptr(PyDateTime_CAPI))
def _PyDateTime_Import(space):
PyDateTime_CAPI = cpython_struct('PyDateTime_CAPI', (
('DateType', PyTypeObjectPtr),
('DateTimeType', PyTypeObjectPtr),
('TimeType', PyTypeObjectPtr),
('DeltaType', PyTypeObjectPtr),
('TZInfoType', PyTypeObjectPtr),
('Date_FromDate',
lltype.Ptr(
lltype.FuncType(
[rffi.INT_real, rffi.INT_real, rffi.INT_real, PyTypeObjectPtr],
PyObject))),
('Time_FromTime',
lltype.Ptr(
lltype.FuncType([
rffi.INT_real, rffi.INT_real, rffi.INT_real, rffi.INT_real,
PyObject, PyTypeObjectPtr
], PyObject))),
('DateTime_FromDateAndTime',
lltype.Ptr(
lltype.FuncType([
rffi.INT_real, rffi.INT_real, rffi.INT_real, rffi.INT_real,
rffi.INT_real, rffi.INT_real, rffi.INT_real, PyObject,
PyTypeObjectPtr
], PyObject))),
('Delta_FromDelta',
lltype.Ptr(
lltype.FuncType([
rffi.INT_real, rffi.INT_real, rffi.INT_real, rffi.INT_real,
PyTypeObjectPtr
], PyObject))),
))
from pypy.module.cpyext.floatobject import PyFloat_AsDouble
from pypy.objspace.std.complexobject import W_ComplexObject
from pypy.interpreter.error import oefmt
PyComplex_Check, PyComplex_CheckExact = build_type_checkers("Complex")
Py_complex_t = rffi.CStruct('Py_complex_t', ('real', rffi.DOUBLE),
('imag', rffi.DOUBLE),
hints={'size': 2 * rffi.sizeof(rffi.DOUBLE)})
Py_complex_ptr = lltype.Ptr(Py_complex_t)
PyComplexObjectStruct = lltype.ForwardReference()
PyComplexObject = lltype.Ptr(PyComplexObjectStruct)
PyComplexObjectFields = PyObjectFields + \
(("cval", Py_complex_t),)
cpython_struct("PyComplexObject", PyComplexObjectFields, PyComplexObjectStruct)
@bootstrap_function
def init_complexobject(space):
"Type description of PyComplexObject"
make_typedescr(space.w_complex.layout.typedef,
basestruct=PyComplexObject.TO,
attach=complex_attach,
realize=complex_realize)
def complex_attach(space, py_obj, w_obj, w_userdata=None):
"""
Fills a newly allocated PyComplexObject with the given complex object. The
value must not be modified.
from pypy.interpreter.error import OperationError
from pypy.rpython.lltypesystem import rffi, lltype
from pypy.module.cpyext.api import (
cpython_api, CANNOT_FAIL, CONST_STRING, FILEP, fread, feof, Py_ssize_tP,
cpython_struct)
from pypy.module.cpyext.pyobject import PyObject, borrow_from
from pypy.module.cpyext.pyerrors import PyErr_SetFromErrno
from pypy.module.__builtin__ import compiling
PyCompilerFlags = cpython_struct(
"PyCompilerFlags", ())
PyCompilerFlagsPtr = lltype.Ptr(PyCompilerFlags)
@cpython_api([PyObject, PyObject, PyObject], PyObject)
def PyEval_CallObjectWithKeywords(space, w_obj, w_arg, w_kwds):
return space.call(w_obj, w_arg, w_kwds)
@cpython_api([], PyObject)
def PyEval_GetBuiltins(space):
"""Return a dictionary of the builtins in the current execution
frame, or the interpreter of the thread state if no frame is
currently executing."""
caller = space.getexecutioncontext().gettopframe_nohidden()
if caller is not None:
w_globals = caller.w_globals
w_builtins = space.getitem(w_globals, space.wrap('__builtins__'))
if not space.isinstance_w(w_builtins, space.w_dict):
w_builtins = w_builtins.getdict(space)
else:
w_builtins = space.builtin.getdict(space)
return borrow_from(None, w_builtins)
cpython_api, cpython_struct, bootstrap_function, build_type_checkers,
CANNOT_FAIL, Py_ssize_t, Py_ssize_tP, PyObjectFields, slot_function)
from pypy.module.cpyext.pyobject import (
decref, PyObject, make_ref, make_typedescr)
from pypy.module.cpyext.pyerrors import PyErr_BadInternalCall
from pypy.interpreter.error import OperationError
from pypy.objspace.std.sliceobject import W_SliceObject
# Slice objects directly expose their members as PyObject.
# Don't change them!
PySliceObjectStruct = lltype.ForwardReference()
PySliceObject = lltype.Ptr(PySliceObjectStruct)
PySliceObjectFields = PyObjectFields + \
(("start", PyObject), ("step", PyObject), ("stop", PyObject), )
cpython_struct("PySliceObject", PySliceObjectFields, PySliceObjectStruct)
@bootstrap_function
def init_sliceobject(space):
"Type description of PySliceObject"
make_typedescr(W_SliceObject.typedef,
basestruct=PySliceObject.TO,
attach=slice_attach,
dealloc=slice_dealloc)
def slice_attach(space, py_obj, w_obj, w_userdata=None):
"""
Fills a newly allocated PySliceObject with the given slice object. The
fields must not be modified.
"""
py_slice = rffi.cast(PySliceObject, py_obj)
from pypy.module.cpyext.buffer import CBuffer
from pypy.module.array.interp_array import ArrayBuffer
from pypy.objspace.std.bufferobject import W_Buffer
PyBufferObjectStruct = lltype.ForwardReference()
PyBufferObject = lltype.Ptr(PyBufferObjectStruct)
PyBufferObjectFields = PyObjectFields + (
("b_base", PyObject),
("b_ptr", rffi.VOIDP),
("b_size", Py_ssize_t),
("b_offset", Py_ssize_t),
("b_readonly", rffi.INT),
("b_hash", rffi.LONG),
)
cpython_struct("PyBufferObject", PyBufferObjectFields, PyBufferObjectStruct)
@bootstrap_function
def init_bufferobject(space):
"Type description of PyBufferObject"
make_typedescr(space.w_buffer.layout.typedef,
basestruct=PyBufferObject.TO,
attach=buffer_attach,
dealloc=buffer_dealloc,
realize=buffer_realize)
def buffer_attach(space, py_obj, w_obj, w_userdata=None):
"""
Fills a newly allocated PyBufferObject with the given buffer object.
from pypy.module.cpyext.bytesobject import PyString_Check
from pypy.module.sys.interp_encoding import setdefaultencoding
from pypy.module._codecs.interp_codecs import CodecState
from pypy.objspace.std import unicodeobject
from rpython.rlib import rstring, runicode
from rpython.tool.sourcetools import func_renamer
import sys
## See comment in bytesobject.py.
PyUnicodeObjectStruct = lltype.ForwardReference()
PyUnicodeObject = lltype.Ptr(PyUnicodeObjectStruct)
PyUnicodeObjectFields = (PyObjectFields +
(("str", rffi.CWCHARP), ("length", Py_ssize_t),
("hash", rffi.LONG), ("defenc", PyObject)))
cpython_struct("PyUnicodeObject", PyUnicodeObjectFields, PyUnicodeObjectStruct)
@bootstrap_function
def init_unicodeobject(space):
make_typedescr(space.w_unicode.layout.typedef,
basestruct=PyUnicodeObject.TO,
attach=unicode_attach,
dealloc=unicode_dealloc,
realize=unicode_realize)
# Buffer for the default encoding (used by PyUnicde_GetDefaultEncoding)
DEFAULT_ENCODING_SIZE = 100
default_encoding = lltype.malloc(rffi.CCHARP.TO, DEFAULT_ENCODING_SIZE,
flavor='raw', zero=True)
PyUnicode_Check, PyUnicode_CheckExact = build_type_checkers("Unicode", "w_unicode")
from rpython.rtyper.lltypesystem import rffi, lltype
from pypy.module.cpyext.api import cpython_api, cpython_struct, \
METH_STATIC, METH_CLASS, METH_COEXIST, CANNOT_FAIL, CONST_STRING
from pypy.module.cpyext.pyobject import PyObject, borrow_from
from pypy.interpreter.module import Module
from pypy.module.cpyext.methodobject import (
W_PyCFunctionObject, PyCFunction_NewEx, PyDescr_NewMethod,
PyMethodDef, PyDescr_NewClassMethod, PyStaticMethod_New)
from pypy.module.cpyext.pyerrors import PyErr_BadInternalCall
from pypy.module.cpyext.state import State
from pypy.interpreter.error import OperationError
PyModuleDef_BaseStruct = cpython_struct(
'PyModuleDef_Base',
[])
PyModuleDefStruct = cpython_struct(
'PyModuleDef',
[('m_base', PyModuleDef_BaseStruct),
('m_name', rffi.CCHARP),
('m_doc', rffi.CCHARP),
('m_methods', lltype.Ptr(PyMethodDef)),
], level=2)
PyModuleDef = lltype.Ptr(PyModuleDefStruct)
@cpython_api([PyModuleDef, rffi.INT_real], PyObject)
def PyModule_Create2(space, module, api_version):
"""Create a new module object, given the definition in module, assuming the
API version module_api_version. If that version does not match the version
of the running interpreter, a RuntimeWarning is emitted.
from pypy.interpreter.error import oefmt
from pypy.interpreter.astcompiler import consts
from rpython.rtyper.lltypesystem import rffi, lltype
from rpython.rlib.objectmodel import we_are_translated
from rpython.rlib.rarithmetic import widen
from pypy.module.cpyext.api import (cpython_api, CANNOT_FAIL, CONST_STRING,
FILEP, fread, feof, Py_ssize_tP,
cpython_struct)
from pypy.module.cpyext.pyobject import PyObject
from pypy.module.cpyext.pyerrors import PyErr_SetFromErrno
from pypy.module.cpyext.funcobject import PyCodeObject
from pypy.module.cpyext.frameobject import PyFrameObject
from pypy.module.__builtin__ import compiling
PyCompilerFlags = cpython_struct("PyCompilerFlags", (("cf_flags", rffi.INT), ))
PyCompilerFlagsPtr = lltype.Ptr(PyCompilerFlags)
PyCF_MASK = (consts.CO_FUTURE_DIVISION | consts.CO_FUTURE_ABSOLUTE_IMPORT
| consts.CO_FUTURE_WITH_STATEMENT
| consts.CO_FUTURE_PRINT_FUNCTION
| consts.CO_FUTURE_UNICODE_LITERALS)
@cpython_api([PyObject, PyObject, PyObject], PyObject)
def PyEval_CallObjectWithKeywords(space, w_obj, w_arg, w_kwds):
return space.call(w_obj, w_arg, w_kwds)
@cpython_api([], PyObject, result_borrowed=True)
def PyEval_GetBuiltins(space):
"""Return a dictionary of the builtins in the current execution
# the bytes are mapped to ints in [0, 256).
# Bytes are not characters; they may be used to encode characters.
# The only way to go between bytes and str/unicode is via encoding
# and decoding.
# For the convenience of C programmers, the bytes type is considered
# to contain a char pointer, not an unsigned char pointer.
# Expose data as a rw cchar* only through PyByteArray_AsString
# Under this strategy the pointer could loose its synchronization with
# the underlying space.w_bytearray if PyByteArray_Resize is called, so
# hopefully the use of the pointer is short-lived
PyByteArrayObjectStruct = lltype.ForwardReference()
PyByteArrayObject = lltype.Ptr(PyByteArrayObjectStruct)
PyByteArrayObjectFields = PyVarObjectFields
cpython_struct("PyByteArrayObject", PyByteArrayObjectFields, PyByteArrayObjectStruct)
PyByteArray_Check, PyByteArray_CheckExact = build_type_checkers("ByteArray", "w_bytearray")
#_______________________________________________________________________
@cpython_api([PyObject], PyObject, result_is_ll=True)
def PyByteArray_FromObject(space, w_obj):
"""Return a new bytearray object from any object, o, that implements the
buffer protocol.
XXX expand about the buffer protocol, at least somewhere"""
w_buffer = space.call_function(space.w_bytearray, w_obj)
return make_ref(space, w_buffer)
@cpython_api([CONST_STRING, Py_ssize_t], PyObject, result_is_ll=True)
from pypy.module.cpyext.api import (cpython_api, generic_cpy_call, CANNOT_FAIL,
CConfig, cpython_struct)
from pypy.module.cpyext.pyobject import PyObject, Py_DecRef, make_ref, from_ref
from rpython.rtyper.lltypesystem import rffi, lltype
from rpython.rlib import rthread
PyInterpreterStateStruct = lltype.ForwardReference()
PyInterpreterState = lltype.Ptr(PyInterpreterStateStruct)
cpython_struct("PyInterpreterState", [('next', PyInterpreterState)],
PyInterpreterStateStruct)
PyThreadState = lltype.Ptr(
cpython_struct("PyThreadState", [
('interp', PyInterpreterState),
('dict', PyObject),
]))
class NoThreads(Exception):
pass
@cpython_api([], PyThreadState, error=CANNOT_FAIL, gil="release")
def PyEval_SaveThread(space):
"""Release the global interpreter lock (if it has been created and thread
support is enabled) and reset the thread state to NULL, returning the
previous thread state. If the lock has been created,
the current thread must have acquired it. (This function is available even
when thread support is disabled at compile time.)"""
state = space.fromcache(InterpreterState)
tstate = state.swap_thread_state(space, lltype.nullptr(PyThreadState.TO))
return tstate
from pypy.module.cpyext.api import bootstrap_function, slot_function
from pypy.module.cpyext.pyobject import make_typedescr
from pypy.module.exceptions.interp_exceptions import W_RuntimeWarning
from pypy.module.exceptions.interp_exceptions import W_StopIteration
from pypy.module.cpyext.pyobject import (PyObject, PyObjectP, make_ref,
from_ref, decref,
get_w_obj_and_decref)
from pypy.module.cpyext.state import State
from pypy.module.cpyext.import_ import PyImport_Import
from rpython.rlib import rposix, jit
PyStopIterationObjectStruct = lltype.ForwardReference()
PyStopIterationObject = lltype.Ptr(PyStopIterationObjectStruct)
PyStopIterationObjectFields = PyObjectFields + \
(("value", PyObject), )
cpython_struct("PyStopIterationObject", PyStopIterationObjectFields,
PyStopIterationObjectStruct)
@bootstrap_function
def init_stopiterationobject(space):
"Type description of PyStopIterationObject"
make_typedescr(W_StopIteration.typedef,
basestruct=PyStopIterationObject.TO,
attach=stopiteration_attach,
dealloc=stopiteration_dealloc)
def stopiteration_attach(space, py_obj, w_obj, w_userdata=None):
py_stopiteration = rffi.cast(PyStopIterationObject, py_obj)
assert isinstance(w_obj, W_StopIteration)
# note: assumes that w_value is read-only; changes on one side won't
cpython_api, cpython_struct, bootstrap_function, build_type_checkers,
CANNOT_FAIL, Py_ssize_t, Py_ssize_tP, PyObjectFields)
from pypy.module.cpyext.pyobject import (
Py_DecRef, PyObject, make_ref, make_typedescr)
from pypy.module.cpyext.pyerrors import PyErr_BadInternalCall
from pypy.interpreter.error import OperationError
from pypy.objspace.std.sliceobject import W_SliceObject
# Slice objects directly expose their members as PyObject.
# Don't change them!
PySliceObjectStruct = lltype.ForwardReference()
PySliceObject = lltype.Ptr(PySliceObjectStruct)
PySliceObjectFields = PyObjectFields + \
(("start", PyObject), ("step", PyObject), ("stop", PyObject), )
cpython_struct("PySliceObject", PySliceObjectFields, PySliceObjectStruct)
@bootstrap_function
def init_sliceobject(space):
"Type description of PySliceObject"
make_typedescr(W_SliceObject.typedef,
basestruct=PySliceObject.TO,
attach=slice_attach,
dealloc=slice_dealloc)
def slice_attach(space, py_obj, w_obj):
"""
Fills a newly allocated PySliceObject with the given slice object. The
fields must not be modified.
"""
py_slice = rffi.cast(PySliceObject, py_obj)
from pypy.module.cpyext.frameobject import PyFrameObject
from rpython.rlib.unroll import unrolling_iterable
from pypy.interpreter.error import OperationError
from pypy.interpreter.pytraceback import PyTraceback
from pypy.interpreter import pycode
PyTracebackObjectStruct = lltype.ForwardReference()
PyTracebackObject = lltype.Ptr(PyTracebackObjectStruct)
PyTracebackObjectFields = PyObjectFields + (
("tb_next", PyTracebackObject),
("tb_frame", PyFrameObject),
("tb_lasti", rffi.INT),
("tb_lineno", rffi.INT),
)
cpython_struct("PyTracebackObject", PyTracebackObjectFields, PyTracebackObjectStruct)
@bootstrap_function
def init_traceback(space):
make_typedescr(PyTraceback.typedef,
basestruct=PyTracebackObject.TO,
attach=traceback_attach,
dealloc=traceback_dealloc)
def traceback_attach(space, py_obj, w_obj):
py_traceback = rffi.cast(PyTracebackObject, py_obj)
traceback = space.interp_w(PyTraceback, w_obj)
if traceback.next is None:
w_next_traceback = None
else:
make_typedescr, get_typedescr)
from pypy.module.cpyext.state import State
from pypy.module.cpyext.pystate import PyThreadState
from pypy.module.cpyext.funcobject import PyCodeObject
from pypy.interpreter.pyframe import PyFrame
from pypy.interpreter.pycode import PyCode
from pypy.interpreter.pytraceback import PyTraceback
PyFrameObjectStruct = lltype.ForwardReference()
PyFrameObject = lltype.Ptr(PyFrameObjectStruct)
PyFrameObjectFields = (PyObjectFields + (
("f_code", PyCodeObject),
("f_globals", PyObject),
("f_lineno", rffi.INT),
))
cpython_struct("PyFrameObject", PyFrameObjectFields, PyFrameObjectStruct)
@bootstrap_function
def init_frameobject(space):
make_typedescr(PyFrame.typedef,
basestruct=PyFrameObject.TO,
attach=frame_attach,
dealloc=frame_dealloc,
realize=frame_realize)
def frame_attach(space, py_obj, w_obj):
"Fills a newly allocated PyFrameObject with a frame object"
frame = space.interp_w(PyFrame, w_obj)
py_frame = rffi.cast(PyFrameObject, py_obj)
wrapperfunc = P(FT([PyO, PyO, rffi.VOIDP], PyO))
wrapperfunc_kwds = P(FT([PyO, PyO, rffi.VOIDP, PyO], PyO))
readbufferproc = P(FT([PyO, Py_ssize_t, rffi.VOIDPP], Py_ssize_t))
writebufferproc = P(FT([PyO, Py_ssize_t, rffi.VOIDPP], Py_ssize_t))
segcountproc = P(FT([PyO, Py_ssize_tP], Py_ssize_t))
charbufferproc = P(FT([PyO, Py_ssize_t, rffi.CCHARPP], Py_ssize_t))
getbufferproc = P(FT([PyO, Py_bufferP, rffi.INT_real], rffi.INT_real))
releasebufferproc = rffi.VOIDP
PyGetSetDef = cpython_struct("PyGetSetDef", (
("name", rffi.CCHARP),
("get", getter),
("set", setter),
("doc", rffi.CCHARP),
("closure", rffi.VOIDP),
))
PyNumberMethods = cpython_struct("PyNumberMethods", (
("nb_add", binaryfunc),
("nb_subtract", binaryfunc),
("nb_multiply", binaryfunc),
("nb_divide", binaryfunc),
("nb_remainder", binaryfunc),
("nb_divmod", binaryfunc),
("nb_power", ternaryfunc),
("nb_negative", unaryfunc),
("nb_positive", unaryfunc),
("nb_absolute", unaryfunc),
from pypy.interpreter.error import OperationError
from pypy.interpreter.astcompiler import consts
from rpython.rtyper.lltypesystem import rffi, lltype
from pypy.module.cpyext.api import (
cpython_api, CANNOT_FAIL, CONST_STRING, FILEP, fread, feof, Py_ssize_tP,
cpython_struct, is_valid_fp)
from pypy.module.cpyext.pyobject import PyObject
from pypy.module.cpyext.pyerrors import PyErr_SetFromErrno
from pypy.module.cpyext.funcobject import PyCodeObject
from pypy.module.__builtin__ import compiling
PyCompilerFlags = cpython_struct(
"PyCompilerFlags", (("cf_flags", rffi.INT),))
PyCompilerFlagsPtr = lltype.Ptr(PyCompilerFlags)
PyCF_MASK = (consts.CO_FUTURE_DIVISION |
consts.CO_FUTURE_ABSOLUTE_IMPORT |
consts.CO_FUTURE_WITH_STATEMENT |
consts.CO_FUTURE_PRINT_FUNCTION |
consts.CO_FUTURE_UNICODE_LITERALS)
@cpython_api([PyObject, PyObject, PyObject], PyObject)
def PyEval_CallObjectWithKeywords(space, w_obj, w_arg, w_kwds):
return space.call(w_obj, w_arg, w_kwds)
@cpython_api([], PyObject, result_borrowed=True)
def PyEval_GetBuiltins(space):
"""Return a dictionary of the builtins in the current execution
frame, or the interpreter of the thread state if no frame is
currently executing."""
caller = space.getexecutioncontext().gettopframe_nohidden()
from pypy.module.cpyext.api import (
cpython_api, generic_cpy_call, CANNOT_FAIL, CConfig, cpython_struct)
from pypy.module.cpyext.pyobject import PyObject, Py_DecRef, make_ref, from_ref
from rpython.rtyper.lltypesystem import rffi, lltype
from rpython.rlib import rthread
PyInterpreterStateStruct = lltype.ForwardReference()
PyInterpreterState = lltype.Ptr(PyInterpreterStateStruct)
cpython_struct(
"PyInterpreterState",
[('next', PyInterpreterState)],
PyInterpreterStateStruct)
PyThreadState = lltype.Ptr(cpython_struct(
"PyThreadState",
[('interp', PyInterpreterState),
('dict', PyObject),
]))
class NoThreads(Exception):
pass
@cpython_api([], PyThreadState, error=CANNOT_FAIL, gil="release")
def PyEval_SaveThread(space):
"""Release the global interpreter lock (if it has been created and thread
support is enabled) and reset the thread state to NULL, returning the
previous thread state. If the lock has been created,
the current thread must have acquired it. (This function is available even
when thread support is disabled at compile time.)"""
state = space.fromcache(InterpreterState)
tstate = state.swap_thread_state(
space, lltype.nullptr(PyThreadState.TO))
wrapperfunc = P(FT([PyO, PyO, rffi.VOIDP], PyO))
wrapperfunc_kwds = P(FT([PyO, PyO, rffi.VOIDP, PyO], PyO))
readbufferproc = P(FT([PyO, Py_ssize_t, rffi.VOIDPP], Py_ssize_t))
writebufferproc = P(FT([PyO, Py_ssize_t, rffi.VOIDPP], Py_ssize_t))
segcountproc = P(FT([PyO, Py_ssize_tP], Py_ssize_t))
charbufferproc = P(FT([PyO, Py_ssize_t, rffi.CCHARPP], Py_ssize_t))
## We don't support new buffer interface for now
getbufferproc = rffi.VOIDP
releasebufferproc = rffi.VOIDP
PyGetSetDef = cpython_struct("PyGetSetDef", (
("name", rffi.CCHARP),
("get", getter),
("set", setter),
("doc", rffi.CCHARP),
("closure", rffi.VOIDP),
))
PyNumberMethods = cpython_struct("PyNumberMethods", (
("nb_add", binaryfunc),
("nb_subtract", binaryfunc),
("nb_multiply", binaryfunc),
("nb_divide", binaryfunc),
("nb_remainder", binaryfunc),
("nb_divmod", binaryfunc),
("nb_power", ternaryfunc),
("nb_negative", unaryfunc),
("nb_positive", unaryfunc),
("nb_absolute", unaryfunc),
PyObject,
PyObjectFields,
bootstrap_function,
build_type_checkers,
cpython_api,
cpython_struct,
generic_cpy_call,
)
from pypy.module.cpyext.pyobject import Py_DecRef, from_ref, make_ref, make_typedescr
PyCFunction_typedef = rffi.COpaquePtr(typedef="PyCFunction")
PyCFunction = lltype.Ptr(lltype.FuncType([PyObject, PyObject], PyObject))
PyCFunctionKwArgs = lltype.Ptr(lltype.FuncType([PyObject, PyObject, PyObject], PyObject))
PyMethodDef = cpython_struct(
"PyMethodDef",
[("ml_name", rffi.CCHARP), ("ml_meth", PyCFunction_typedef), ("ml_flags", rffi.INT_real), ("ml_doc", rffi.CCHARP)],
)
PyCFunctionObjectStruct = cpython_struct(
"PyCFunctionObject",
PyObjectFields + (("m_ml", lltype.Ptr(PyMethodDef)), ("m_self", PyObject), ("m_module", PyObject)),
)
PyCFunctionObject = lltype.Ptr(PyCFunctionObjectStruct)
@bootstrap_function
def init_methodobject(space):
make_typedescr(
W_PyCFunctionObject.typedef, basestruct=PyCFunctionObject.TO, attach=cfunction_attach, dealloc=cfunction_dealloc
)
## PyBytes_AsString / PyString_AsString
## PyBytes_AS_STRING / PyString_AS_STRING
## PyBytes_AsStringAndSize / PyString_AsStringAndSize
## PyBytes_Size / PyString_Size
## PyBytes_Resize / PyString_Resize
## _PyBytes_Resize / _PyString_Resize (raises if called with a forced object)
##
## - There could be an (expensive!) check in from_ref() that the buffer still
## corresponds to the pypy gc-managed string,
##
PyBytesObjectStruct = lltype.ForwardReference()
PyBytesObject = lltype.Ptr(PyBytesObjectStruct)
PyBytesObjectFields = PyVarObjectFields + \
(("ob_shash", rffi.LONG), ("ob_sstate", rffi.INT), ("ob_sval", rffi.CArray(lltype.Char)))
cpython_struct("PyBytesObject", PyBytesObjectFields, PyBytesObjectStruct)
@bootstrap_function
def init_bytesobject(space):
"Type description of PyBytesObject"
make_typedescr(space.w_bytes.layout.typedef,
basestruct=PyBytesObject.TO,
attach=bytes_attach,
dealloc=bytes_dealloc,
realize=bytes_realize)
PyBytes_Check, PyBytes_CheckExact = build_type_checkers_flags(
"Bytes", "w_bytes")
from pypy.rpython.lltypesystem import rffi, lltype
from pypy.module.cpyext.pyobject import PyObject, make_ref
from pypy.module.cpyext.api import (cpython_api, CANNOT_FAIL, cpython_struct,
PyObjectFields)
from pypy.module.cpyext.import_ import PyImport_Import
from pypy.module.cpyext.typeobject import PyTypeObjectPtr
from pypy.interpreter.error import OperationError
from pypy.tool.sourcetools import func_renamer
# API import function
PyDateTime_CAPI = cpython_struct(
'PyDateTime_CAPI',
(('DateType', PyTypeObjectPtr),
('DateTimeType', PyTypeObjectPtr),
('TimeType', PyTypeObjectPtr),
('DeltaType', PyTypeObjectPtr),
))
@cpython_api([], lltype.Ptr(PyDateTime_CAPI))
def _PyDateTime_Import(space):
datetimeAPI = lltype.malloc(PyDateTime_CAPI, flavor='raw',
track_allocation=False)
w_datetime = PyImport_Import(space, space.wrap("datetime"))
w_type = space.getattr(w_datetime, space.wrap("date"))
datetimeAPI.c_DateType = rffi.cast(
PyTypeObjectPtr, make_ref(space, w_type))
w_type = space.getattr(w_datetime, space.wrap("datetime"))
## These two PyPy classes implement getitem() by returning a freshly
## constructed W_IntObject or W_FloatObject. This is not compatible
## with PyTuple_GetItem, which returns a borrowed reference.
##
## So we use this more advanced (but also likely faster) solution:
## tuple_attach makes a real PyTupleObject with an array of N
## 'PyObject *', which are created immediately and own a reference.
## Then the macro PyTuple_GET_ITEM can be implemented like CPython.
##
PyTupleObjectStruct = lltype.ForwardReference()
PyTupleObject = lltype.Ptr(PyTupleObjectStruct)
ObjectItems = rffi.CArray(PyObject)
PyTupleObjectFields = PyVarObjectFields + \
(("ob_item", ObjectItems),)
cpython_struct("PyTupleObject", PyTupleObjectFields, PyTupleObjectStruct)
@bootstrap_function
def init_stringobject(space):
"Type description of PyTupleObject"
make_typedescr(space.w_tuple.layout.typedef,
basestruct=PyTupleObject.TO,
attach=tuple_attach,
dealloc=tuple_dealloc,
realize=tuple_realize)
PyTuple_Check, PyTuple_CheckExact = build_type_checkers("Tuple")
def tuple_check_ref(space, ref):
w_type = from_ref(space, rffi.cast(PyObject, ref.c_ob_type))
return (w_type is space.w_tuple or
from pypy.interpreter.error import OperationError
from pypy.rpython.lltypesystem import rffi, lltype
from pypy.module.cpyext.api import (cpython_api, CANNOT_FAIL, CONST_STRING,
FILEP, fread, feof, Py_ssize_tP,
cpython_struct)
from pypy.module.cpyext.pyobject import PyObject, borrow_from
from pypy.module.cpyext.pyerrors import PyErr_SetFromErrno
from pypy.module.__builtin__ import compiling
PyCompilerFlags = cpython_struct("PyCompilerFlags", ())
PyCompilerFlagsPtr = lltype.Ptr(PyCompilerFlags)
@cpython_api([PyObject, PyObject, PyObject], PyObject)
def PyEval_CallObjectWithKeywords(space, w_obj, w_arg, w_kwds):
return space.call(w_obj, w_arg, w_kwds)
@cpython_api([], PyObject)
def PyEval_GetBuiltins(space):
"""Return a dictionary of the builtins in the current execution
frame, or the interpreter of the thread state if no frame is
currently executing."""
caller = space.getexecutioncontext().gettopframe_nohidden()
if caller is not None:
w_globals = caller.w_globals
w_builtins = space.getitem(w_globals, space.wrap('__builtins__'))
if not space.isinstance_w(w_builtins, space.w_dict):
w_builtins = w_builtins.getdict(space)
else:
w_builtins = space.builtin.getdict(space)
from rpython.rtyper.lltypesystem import rffi, lltype
from pypy.module.cpyext.api import (PyObjectFields, bootstrap_function,
cpython_struct, CANNOT_FAIL, cpython_api,
PyObject, build_type_checkers,
CONST_STRING)
from pypy.module.cpyext.pyobject import (make_typedescr, track_reference,
from_ref)
from pypy.interpreter.error import OperationError
from rpython.rlib.rstruct import runpack
from pypy.objspace.std.floatobject import W_FloatObject
PyFloatObjectStruct = lltype.ForwardReference()
PyFloatObject = lltype.Ptr(PyFloatObjectStruct)
PyFloatObjectFields = PyObjectFields + \
(("ob_fval", rffi.DOUBLE),)
cpython_struct("PyFloatObject", PyFloatObjectFields, PyFloatObjectStruct)
@bootstrap_function
def init_floatobject(space):
"Type description of PyFloatObject"
make_typedescr(space.w_float.layout.typedef,
basestruct=PyFloatObject.TO,
attach=float_attach,
realize=float_realize)
def float_attach(space, py_obj, w_obj, w_userdata=None):
"""
Fills a newly allocated PyFloatObject with the given float object. The
value must not be modified.
from pypy.module.cpyext.api import (cpython_api, generic_cpy_call, CANNOT_FAIL,
CConfig, cpython_struct)
from pypy.rpython.lltypesystem import rffi, lltype
PyInterpreterStateStruct = lltype.ForwardReference()
PyInterpreterState = lltype.Ptr(PyInterpreterStateStruct)
cpython_struct("PyInterpreterState", [('next', PyInterpreterState)],
PyInterpreterStateStruct)
PyThreadState = lltype.Ptr(
cpython_struct("PyThreadState", [('interp', PyInterpreterState)]))
@cpython_api([], PyThreadState, error=CANNOT_FAIL)
def PyEval_SaveThread(space):
"""Release the global interpreter lock (if it has been created and thread
support is enabled) and reset the thread state to NULL, returning the
previous thread state (which is not NULL except in PyPy). If the lock has been created,
the current thread must have acquired it. (This function is available even
when thread support is disabled at compile time.)"""
if rffi.aroundstate.before:
rffi.aroundstate.before()
return lltype.nullptr(PyThreadState.TO)
@cpython_api([PyThreadState], lltype.Void)
def PyEval_RestoreThread(space, tstate):
"""Acquire the global interpreter lock (if it has been created and thread
support is enabled) and set the thread state to tstate, which must not be
NULL. If the lock has been created, the current thread must not have
acquired it, otherwise deadlock ensues. (This function is available even
when thread support is disabled at compile time.)"""
from pypy.module.cpyext.api import (
CONST_STRING, METH_CLASS, METH_COEXIST, METH_KEYWORDS, METH_NOARGS, METH_O,
METH_STATIC, METH_VARARGS, PyObject, PyObjectFields, bootstrap_function,
build_type_checkers, cpython_api, cpython_struct, generic_cpy_call)
from pypy.module.cpyext.pyobject import (
Py_DecRef, from_ref, make_ref, make_typedescr)
PyCFunction_typedef = rffi.COpaquePtr(typedef='PyCFunction')
PyCFunction = lltype.Ptr(lltype.FuncType([PyObject, PyObject], PyObject))
PyCFunctionKwArgs = lltype.Ptr(lltype.FuncType([PyObject, PyObject, PyObject],
PyObject))
PyMethodDef = cpython_struct(
'PyMethodDef',
[('ml_name', rffi.CCHARP),
('ml_meth', PyCFunction_typedef),
('ml_flags', rffi.INT_real),
('ml_doc', rffi.CCHARP),
])
PyCFunctionObjectStruct = cpython_struct(
'PyCFunctionObject',
PyObjectFields + (
('m_ml', lltype.Ptr(PyMethodDef)),
('m_self', PyObject),
('m_module', PyObject),
))
PyCFunctionObject = lltype.Ptr(PyCFunctionObjectStruct)
@bootstrap_function
def init_methodobject(space):
from pypy.interpreter.error import OperationError
from pypy.module.array.interp_array import ArrayBuffer
PyBufferObjectStruct = lltype.ForwardReference()
PyBufferObject = lltype.Ptr(PyBufferObjectStruct)
PyBufferObjectFields = PyObjectFields + (
("b_base", PyObject),
("b_ptr", rffi.VOIDP),
("b_size", Py_ssize_t),
("b_offset", Py_ssize_t),
("b_readonly", rffi.INT),
("b_hash", rffi.LONG),
)
cpython_struct("PyBufferObject", PyBufferObjectFields, PyBufferObjectStruct)
@bootstrap_function
def init_bufferobject(space):
"Type description of PyBufferObject"
make_typedescr(space.gettypefor(Buffer).instancetypedef,
basestruct=PyBufferObject.TO,
attach=buffer_attach,
dealloc=buffer_dealloc,
realize=buffer_realize)
def buffer_attach(space, py_obj, w_obj):
"""
Fills a newly allocated PyBufferObject with the given (str) buffer object.
"""
py_buf = rffi.cast(PyBufferObject, py_obj)
METH_KEYWORDS, METH_NOARGS, METH_O,
METH_STATIC, METH_VARARGS, PyObject,
PyObjectFields, bootstrap_function,
build_type_checkers, cpython_api,
cpython_struct, generic_cpy_call)
from pypy.module.cpyext.pyobject import (Py_DecRef, from_ref, make_ref,
make_typedescr)
PyCFunction_typedef = rffi.COpaquePtr(typedef='PyCFunction')
PyCFunction = lltype.Ptr(lltype.FuncType([PyObject, PyObject], PyObject))
PyCFunctionKwArgs = lltype.Ptr(
lltype.FuncType([PyObject, PyObject, PyObject], PyObject))
PyMethodDef = cpython_struct('PyMethodDef', [
('ml_name', rffi.CCHARP),
('ml_meth', PyCFunction_typedef),
('ml_flags', rffi.INT_real),
('ml_doc', rffi.CCHARP),
])
PyCFunctionObjectStruct = cpython_struct(
'PyCFunctionObject', PyObjectFields + (
('m_ml', lltype.Ptr(PyMethodDef)),
('m_self', PyObject),
('m_module', PyObject),
))
PyCFunctionObject = lltype.Ptr(PyCFunctionObjectStruct)
@bootstrap_function
def init_methodobject(space):
make_typedescr(W_PyCFunctionObject.typedef,
from_ref, make_typedescr,
get_typedescr, track_reference)
from rpython.rtyper.lltypesystem import lltype, rffi
from rpython.rlib.rarithmetic import widen
from pypy.objspace.std.memoryobject import W_MemoryView
from pypy.module.cpyext.object import _dealloc
from pypy.module.cpyext.import_ import PyImport_Import
PyMemoryView_Check, PyMemoryView_CheckExact = build_type_checkers("MemoryView")
PyMemoryViewObjectStruct = lltype.ForwardReference()
PyMemoryViewObject = lltype.Ptr(PyMemoryViewObjectStruct)
PyMemoryViewObjectFields = PyObjectFields + \
(("view", Py_buffer),)
cpython_struct("PyMemoryViewObject",
PyMemoryViewObjectFields,
PyMemoryViewObjectStruct,
level=2)
@bootstrap_function
def init_memoryobject(space):
"Type description of PyDictObject"
make_typedescr(
W_MemoryView.typedef,
basestruct=PyMemoryViewObject.TO,
attach=memory_attach,
dealloc=memory_dealloc,
realize=memory_realize,
)
from pypy.module.cpyext.api import (cpython_api, CANNOT_FAIL,
build_type_checkers_flags, Py_ssize_t,
Py_ssize_tP, CONST_STRING, PyObjectFields,
cpython_struct, bootstrap_function,
slot_function)
from pypy.module.cpyext.pyobject import (PyObject, PyObjectP, as_pyobj,
make_typedescr, track_reference,
create_ref, from_ref, decref, incref)
from pypy.module.cpyext.object import _dealloc
from pypy.module.cpyext.pyerrors import PyErr_BadInternalCall
PyDictObjectStruct = lltype.ForwardReference()
PyDictObject = lltype.Ptr(PyDictObjectStruct)
PyDictObjectFields = PyObjectFields + \
(("_tmpkeys", PyObject),)
cpython_struct("PyDictObject", PyDictObjectFields, PyDictObjectStruct)
@bootstrap_function
def init_dictobject(space):
"Type description of PyDictObject"
make_typedescr(space.w_dict.layout.typedef,
basestruct=PyDictObject.TO,
attach=dict_attach,
dealloc=dict_dealloc,
realize=dict_realize)
def dict_attach(space, py_obj, w_obj, w_userdata=None):
"""
Fills a newly allocated PyDictObject with the given dict object.
__delete__ = interp2app(GetSetProperty.descr_property_del),
__name__ = interp_attrproperty('name', cls=GetSetProperty,
wrapfn="newtext_or_none"),
__objclass__ = GetSetProperty(GetSetProperty.descr_get_objclass),
__doc__ = interp_attrproperty('doc', cls=GetSetProperty,
wrapfn="newtext_or_none"),
)
assert not W_MemberDescr.typedef.acceptable_as_base_class # no __new__
PyDescrObject = lltype.ForwardReference()
PyDescrObjectPtr = lltype.Ptr(PyDescrObject)
PyDescrObjectFields = PyObjectFields + (
("d_type", PyTypeObjectPtr),
("d_name", PyObject),
)
cpython_struct("PyDescrObject", PyDescrObjectFields,
PyDescrObject)
PyMemberDescrObjectStruct = lltype.ForwardReference()
PyMemberDescrObject = lltype.Ptr(PyMemberDescrObjectStruct)
PyMemberDescrObjectFields = PyDescrObjectFields + (
("d_member", lltype.Ptr(PyMemberDef)),
)
cpython_struct("PyMemberDescrObject", PyMemberDescrObjectFields,
PyMemberDescrObjectStruct, level=2)
PyGetSetDescrObjectStruct = lltype.ForwardReference()
PyGetSetDescrObject = lltype.Ptr(PyGetSetDescrObjectStruct)
PyGetSetDescrObjectFields = PyDescrObjectFields + (
("d_getset", lltype.Ptr(PyGetSetDef)),
)
cpython_struct("PyGetSetDescrObject", PyGetSetDescrObjectFields,
make_ref, from_ref, track_reference,
make_typedescr, get_typedescr)
from pypy.module.cpyext.stringobject import PyString_Check
from pypy.module.sys.interp_encoding import setdefaultencoding
from pypy.objspace.std import unicodeobject, unicodetype
from pypy.rlib import runicode
from pypy.tool.sourcetools import func_renamer
import sys
## See comment in stringobject.py.
PyUnicodeObjectStruct = lltype.ForwardReference()
PyUnicodeObject = lltype.Ptr(PyUnicodeObjectStruct)
PyUnicodeObjectFields = (PyObjectFields + (("buffer", rffi.CWCHARP),
("size", Py_ssize_t)))
cpython_struct("PyUnicodeObject", PyUnicodeObjectFields, PyUnicodeObjectStruct)
@bootstrap_function
def init_unicodeobject(space):
make_typedescr(space.w_unicode.instancetypedef,
basestruct=PyUnicodeObject.TO,
attach=unicode_attach,
dealloc=unicode_dealloc,
realize=unicode_realize)
# Buffer for the default encoding (used by PyUnicde_GetDefaultEncoding)
DEFAULT_ENCODING_SIZE = 100
default_encoding = lltype.malloc(rffi.CCHARP.TO,
DEFAULT_ENCODING_SIZE,
make_typedescr, get_typedescr)
from pypy.module.cpyext.state import State
from pypy.module.cpyext.pystate import PyThreadState
from pypy.module.cpyext.funcobject import PyCodeObject
from pypy.interpreter.pyframe import PyFrame
from pypy.interpreter.pycode import PyCode
from pypy.interpreter.pytraceback import PyTraceback
PyFrameObjectStruct = lltype.ForwardReference()
PyFrameObject = lltype.Ptr(PyFrameObjectStruct)
PyFrameObjectFields = (PyObjectFields +
(("f_code", PyCodeObject),
("f_globals", PyObject),
("f_lineno", rffi.INT),
))
cpython_struct("PyFrameObject", PyFrameObjectFields, PyFrameObjectStruct)
@bootstrap_function
def init_frameobject(space):
make_typedescr(PyFrame.typedef,
basestruct=PyFrameObject.TO,
attach=frame_attach,
dealloc=frame_dealloc,
realize=frame_realize)
def frame_attach(space, py_obj, w_obj):
"Fills a newly allocated PyFrameObject with a frame object"
frame = space.interp_w(PyFrame, w_obj)
py_frame = rffi.cast(PyFrameObject, py_obj)
py_frame.c_f_code = rffi.cast(PyCodeObject, make_ref(space, frame.pycode))
py_frame.c_f_globals = make_ref(space, frame.w_globals)
## These two PyPy classes implement getitem() by returning a freshly
## constructed W_IntObject or W_FloatObject. This is not compatible
## with PyTuple_GetItem, which returns a borrowed reference.
##
## So we use this more advanced (but also likely faster) solution:
## tuple_attach makes a real PyTupleObject with an array of N
## 'PyObject *', which are created immediately and own a reference.
## Then the macro PyTuple_GET_ITEM can be implemented like CPython.
##
PyTupleObjectStruct = lltype.ForwardReference()
PyTupleObject = lltype.Ptr(PyTupleObjectStruct)
ObjectItems = rffi.CArray(PyObject)
PyTupleObjectFields = PyVarObjectFields + \
(("ob_item", ObjectItems),)
cpython_struct("PyTupleObject", PyTupleObjectFields, PyTupleObjectStruct)
@bootstrap_function
def init_stringobject(space):
"Type description of PyTupleObject"
make_typedescr(space.w_tuple.layout.typedef,
basestruct=PyTupleObject.TO,
attach=tuple_attach,
dealloc=tuple_dealloc,
realize=tuple_realize)
PyTuple_Check, PyTuple_CheckExact = build_type_checkers("Tuple")
def tuple_check_ref(space, ref):
w_type = from_ref(space, rffi.cast(PyObject, ref.c_ob_type))
return (w_type is space.w_tuple or
from pypy.module.cpyext.pyobject import (PyObject, make_ref, from_ref, decref,
make_typedescr)
from pypy.module.cpyext.frameobject import PyFrameObject
from pypy.interpreter.error import OperationError
from pypy.interpreter.pytraceback import PyTraceback
from pypy.interpreter import pycode
PyTracebackObjectStruct = lltype.ForwardReference()
PyTracebackObject = lltype.Ptr(PyTracebackObjectStruct)
PyTracebackObjectFields = PyObjectFields + (
("tb_next", PyTracebackObject),
("tb_frame", PyFrameObject),
("tb_lasti", rffi.INT),
("tb_lineno", rffi.INT),
)
cpython_struct("PyTracebackObject", PyTracebackObjectFields,
PyTracebackObjectStruct)
@bootstrap_function
def init_traceback(space):
make_typedescr(PyTraceback.typedef,
basestruct=PyTracebackObject.TO,
attach=traceback_attach,
dealloc=traceback_dealloc)
def traceback_attach(space, py_obj, w_obj, w_userdata=None):
py_traceback = rffi.cast(PyTracebackObject, py_obj)
traceback = space.interp_w(PyTraceback, w_obj)
if traceback.next is None:
w_next_traceback = None
CODE_FLAGS = dict(
CO_OPTIMIZED=0x0001,
CO_NEWLOCALS=0x0002,
CO_VARARGS=0x0004,
CO_VARKEYWORDS=0x0008,
CO_NESTED=0x0010,
CO_GENERATOR=0x0020,
)
ALL_CODE_FLAGS = unrolling_iterable(CODE_FLAGS.items())
PyFunctionObjectStruct = lltype.ForwardReference()
PyFunctionObject = lltype.Ptr(PyFunctionObjectStruct)
PyFunctionObjectFields = PyObjectFields + \
(("func_name", PyObject),)
cpython_struct("PyFunctionObject", PyFunctionObjectFields,
PyFunctionObjectStruct)
PyCodeObjectStruct = lltype.ForwardReference()
PyCodeObject = lltype.Ptr(PyCodeObjectStruct)
PyCodeObjectFields = PyObjectFields + \
(("co_name", PyObject),
("co_filename", PyObject),
("co_flags", rffi.INT),
("co_argcount", rffi.INT),
)
cpython_struct("PyCodeObject", PyCodeObjectFields, PyCodeObjectStruct)
@bootstrap_function
def init_functionobject(space):
make_typedescr(Function.typedef,
from rpython.rtyper.lltypesystem import rffi, lltype
from pypy.module.cpyext.api import cpython_api, cpython_struct, \
METH_STATIC, METH_CLASS, METH_COEXIST, CANNOT_FAIL, CONST_STRING
from pypy.module.cpyext.pyobject import PyObject, borrow_from
from pypy.interpreter.module import Module
from pypy.module.cpyext.methodobject import (W_PyCFunctionObject,
PyCFunction_NewEx,
PyDescr_NewMethod, PyMethodDef,
PyDescr_NewClassMethod,
PyStaticMethod_New)
from pypy.module.cpyext.pyerrors import PyErr_BadInternalCall
from pypy.module.cpyext.state import State
from pypy.interpreter.error import OperationError
PyModuleDef_BaseStruct = cpython_struct('PyModuleDef_Base', [])
PyModuleDefStruct = cpython_struct('PyModuleDef', [
('m_base', PyModuleDef_BaseStruct),
('m_name', rffi.CCHARP),
('m_doc', rffi.CCHARP),
('m_methods', lltype.Ptr(PyMethodDef)),
],
level=2)
PyModuleDef = lltype.Ptr(PyModuleDefStruct)
@cpython_api([PyModuleDef, rffi.INT_real], PyObject)
def PyModule_Create2(space, module, api_version):
"""Create a new module object, given the definition in module, assuming the
API version module_api_version. If that version does not match the version
of the running interpreter, a RuntimeWarning is emitted.
