def test_values_array_signed():
ar = values_array(lltype.Signed, 50)
adr = ar.get_addr_for_num(10)
rffi.cast(rffi.CArrayPtr(lltype.Signed), adr)[0] = 42
assert ar.getitem(10) == 42
ar.setitem(42, 38)
adr = ar.get_addr_for_num(42)
assert rffi.cast(rffi.CArrayPtr(lltype.Signed), adr)[0] == 38
def test_values_array_float():
ar = values_array(lltype.Float, 50)
adr = ar.get_addr_for_num(10)
rffi.cast(rffi.CArrayPtr(lltype.Float), adr)[0] = 42.5
assert ar.getitem(10) == 42.5
ar.setitem(42, 38.5)
adr = ar.get_addr_for_num(42)
assert rffi.cast(rffi.CArrayPtr(lltype.Float), adr)[0] == 38.5
def do_recv_string(self, space, buflength, maxlength):
from pypy.module._multiprocessing.interp_win32 import (
_ReadFile, _PeekNamedPipe, ERROR_BROKEN_PIPE, ERROR_MORE_DATA)
from pypy.rlib import rwin32
from pypy.interpreter.error import wrap_windowserror
read_ptr = lltype.malloc(rffi.CArrayPtr(rwin32.DWORD).TO,
1,
flavor='raw')
left_ptr = lltype.malloc(rffi.CArrayPtr(rwin32.DWORD).TO,
1,
flavor='raw')
try:
result = _ReadFile(self.handle, self.buffer,
min(self.BUFFER_SIZE, buflength), read_ptr,
rffi.NULL)
if result:
return intmask(read_ptr[0]), lltype.nullptr(rffi.CCHARP.TO)
err = rwin32.GetLastError()
if err == ERROR_BROKEN_PIPE:
raise OperationError(space.w_EOFError, space.w_None)
elif err != ERROR_MORE_DATA:
raise wrap_windowserror(space, WindowsError(err, "_ReadFile"))
# More data...
if not _PeekNamedPipe(self.handle, rffi.NULL, 0,
lltype.nullptr(rwin32.LPDWORD.TO),
lltype.nullptr(rwin32.LPDWORD.TO), left_ptr):
raise wrap_windowserror(space, rwin32.lastWindowsError())
length = intmask(read_ptr[0] + left_ptr[0])
if length > maxlength: # bad message, close connection
self.flags &= ~READABLE
if self.flags == 0:
self.close()
raise OperationError(space.w_IOError,
space.wrap("bad message length"))
newbuf = lltype.malloc(rffi.CCHARP.TO, length + 1, flavor='raw')
for i in range(read_ptr[0]):
newbuf[i] = self.buffer[i]
result = _ReadFile(self.handle, rffi.ptradd(newbuf, read_ptr[0]),
left_ptr[0], read_ptr, rffi.NULL)
if not result:
rffi.free_charp(newbuf)
raise wrap_windowserror(space, rwin32.lastWindowsError())
assert read_ptr[0] == left_ptr[0]
return length, newbuf
finally:
lltype.free(read_ptr, flavor='raw')
lltype.free(left_ptr, flavor='raw')
def convertCollection(space, environment, value, var, objectType):
"Convert a collection to a Python list"
result_w = []
iterptr = lltype.malloc(rffi.CArrayPtr(roci.OCIIter).TO, 1, flavor='raw')
try:
# create the iterator
status = roci.OCIIterCreate(environment.handle,
environment.errorHandle, value, iterptr)
environment.checkForError(
status, "ExternalObjectVar_ConvertCollection(): creating iterator")
try:
# create the result list
valueptr = lltype.malloc(rffi.CArrayPtr(roci.dvoidp).TO,
1,
flavor='raw')
indicatorptr = lltype.malloc(rffi.CArrayPtr(roci.dvoidp).TO,
1,
flavor='raw')
eofptr = lltype.malloc(rffi.CArrayPtr(roci.boolean).TO,
1,
flavor='raw')
try:
while True:
status = roci.OCIIterNext(environment.handle,
environment.errorHandle,
iterptr[0], valueptr,
indicatorptr, eofptr)
environment.checkForError(
status,
"ExternalObjectVar_ConvertCollection(): get next")
if rffi.cast(lltype.Signed, eofptr[0]):
break
element = convertObject(space, environment,
objectType.elementTypeCode,
valueptr[0], indicatorptr[0], var,
objectType.elementType)
result_w.append(element)
finally:
lltype.free(valueptr, flavor='raw')
lltype.free(indicatorptr, flavor='raw')
lltype.free(eofptr, flavor='raw')
finally:
roci.OCIIterDelete(environment.handle, environment.errorHandle,
iterptr)
finally:
lltype.free(iterptr, flavor='raw')
return space.newlist(result_w)
def test_typedef():
T = Typedef(Signed, 'T')
assert T == Signed
assert Signed == T
T2 = Typedef(T, 'T2')
assert T2 == T
assert T2.OF is Signed
py.test.raises(TypeError, Ptr, T)
assert rffi.CArrayPtr(T) == rffi.CArrayPtr(Signed)
assert rffi.CArrayPtr(Signed) == rffi.CArrayPtr(T)
F = FuncType((T, ), T)
assert F.RESULT == Signed
assert F.ARGS == (Signed, )
def do_strsetitem(self, stringbox, indexbox, vbox):
basesize, itemsize, ofs_length = symbolic.get_array_token(
rstr.STR, self.translate_support_code)
index = indexbox.getint()
v = vbox.getint()
a = stringbox.getref_base()
rffi.cast(rffi.CArrayPtr(lltype.Char), a)[index + basesize] = chr(v)
def do_strgetitem(self, stringbox, indexbox):
basesize, itemsize, ofs_length = symbolic.get_array_token(
rstr.STR, self.translate_support_code)
gcref = stringbox.getref_base()
i = indexbox.getint()
v = rffi.cast(rffi.CArrayPtr(lltype.Char), gcref)[basesize + i]
return BoxInt(ord(v))
def do_strlen(self, stringbox):
basesize, itemsize, ofs_length = symbolic.get_array_token(
TP, self.translate_support_code)
gcref = stringbox.getref_base()
v = rffi.cast(rffi.CArrayPtr(lltype.Signed),
gcref)[ofs_length / WORD]
return BoxInt(v)
def _internalFetch(self, space, numRows):
if not self.fetchVariables:
raise OperationError(
get(space).w_InterfaceError, space.wrap("query not executed"))
status = roci.OCIStmtFetch(self.handle, self.environment.errorHandle,
numRows, roci.OCI_FETCH_NEXT,
roci.OCI_DEFAULT)
if status != roci.OCI_NO_DATA:
self.environment.checkForError(status,
"Cursor_InternalFetch(): fetch")
for var in self.fetchVariables:
assert isinstance(var, interp_variable.W_Variable)
var.internalFetchNum += 1
attrptr = lltype.malloc(rffi.CArrayPtr(roci.ub4).TO, 1, flavor='raw')
try:
status = roci.OCIAttrGet(self.handle, roci.OCI_HTYPE_STMT,
rffi.cast(roci.dvoidp, attrptr),
lltype.nullptr(roci.Ptr(roci.ub4).TO),
roci.OCI_ATTR_ROW_COUNT,
self.environment.errorHandle)
self.environment.checkForError(
status, "Cursor_InternalFetch(): row count")
self.actualRows = (rffi.cast(lltype.Signed, attrptr[0]) -
self.rowCount)
self.rowNum = 0
finally:
lltype.free(attrptr, flavor='raw')
def getDescription(self, space):
"Return a list of 7-tuples consisting of the description of "
"the define variables"
# make sure the cursor is open
self._checkOpen(space)
# fixup bound cursor, if necessary
self._fixupBoundCursor()
# if not a query, return None
if self.statementType != roci.OCI_STMT_SELECT:
return
# determine number of items in select-list
attrptr = lltype.malloc(rffi.CArrayPtr(roci.ub1).TO, 1, flavor='raw')
try:
status = roci.OCIAttrGet(self.handle, roci.OCI_HTYPE_STMT,
rffi.cast(roci.dvoidp, attrptr),
lltype.nullptr(roci.Ptr(roci.ub4).TO),
roci.OCI_ATTR_PARAM_COUNT,
self.environment.errorHandle)
self.environment.checkForError(status, "Cursor_GetDescription()")
numItems = attrptr[0]
finally:
lltype.free(attrptr, flavor='raw')
return space.newlist([
space.newtuple(self._itemDescription(space, i + 1))
for i in range(numItems)
])
def do_new_with_vtable(self, classbox):
classint = classbox.getint()
descrsize = self.class_sizes[classint]
res = self.gc_ll_descr.gc_malloc(descrsize)
as_array = rffi.cast(rffi.CArrayPtr(lltype.Signed), res)
as_array[self.vtable_offset / WORD] = classint
return BoxPtr(res)
def test_array_fields(self):
POINT = lltype.Struct(
"POINT",
("x", lltype.Float),
("y", lltype.Float),
)
points = lltype.malloc(rffi.CArray(POINT), 2, flavor="raw")
points[0].x = 1.0
points[0].y = 2.0
points[1].x = 3.0
points[1].y = 4.0
points = rffi.cast(rffi.CArrayPtr(lltype.Char), points)
assert array_getitem(types.double, 16, points, 0, 0) == 1.0
assert array_getitem(types.double, 16, points, 0, 8) == 2.0
assert array_getitem(types.double, 16, points, 1, 0) == 3.0
assert array_getitem(types.double, 16, points, 1, 8) == 4.0
#
array_setitem(types.double, 16, points, 0, 0, 10.0)
array_setitem(types.double, 16, points, 0, 8, 20.0)
array_setitem(types.double, 16, points, 1, 0, 30.0)
array_setitem(types.double, 16, points, 1, 8, 40.0)
#
assert array_getitem(types.double, 16, points, 0, 0) == 10.0
assert array_getitem(types.double, 16, points, 0, 8) == 20.0
assert array_getitem(types.double, 16, points, 1, 0) == 30.0
assert array_getitem(types.double, 16, points, 1, 8) == 40.0
#
lltype.free(points, flavor="raw")
def Py_FindMethod(space, table, w_obj, name_ptr):
"""Return a bound method object for an extension type implemented in C. This
can be useful in the implementation of a tp_getattro or
tp_getattr handler that does not use the
PyObject_GenericGetAttr() function."""
# XXX handle __doc__
name = rffi.charp2str(name_ptr)
methods = rffi.cast(rffi.CArrayPtr(PyMethodDef), table)
method_list_w = []
if methods:
i = -1
while True:
i = i + 1
method = methods[i]
if not method.c_ml_name: break
if name == "__methods__":
method_list_w.append(
space.wrap(rffi.charp2str(method.c_ml_name)))
elif rffi.charp2str(
method.c_ml_name) == name: # XXX expensive copying
return space.wrap(W_PyCFunctionObject(space, method, w_obj))
if name == "__methods__":
return space.newlist(method_list_w)
raise OperationError(space.w_AttributeError, space.wrap(name))
def _performDefine(self):
# determine number of items in select-list
attrptr = lltype.malloc(rffi.CArrayPtr(roci.ub4).TO,
1, flavor='raw')
try:
status = roci.OCIAttrGet(
self.handle, roci.OCI_HTYPE_STMT,
rffi.cast(roci.dvoidp, attrptr),
lltype.nullptr(roci.Ptr(roci.ub4).TO),
roci.OCI_ATTR_PARAM_COUNT,
self.environment.errorHandle)
self.environment.checkForError(
status, "Cursor_PerformDefine()")
numParams = attrptr[0]
finally:
lltype.free(attrptr, flavor='raw')
self.fetchVariables = []
# define a variable for each select-item
self.fetchArraySize = self.arraySize
for i in range(numParams):
var = interp_variable.define(self, i+1, self.fetchArraySize)
assert isinstance(var, interp_variable.W_Variable)
self.fetchVariables.append(var)
def _setRowCount(self):
if self.statementType == roci.OCI_STMT_SELECT:
self.rowCount = 0
self.actualRows = -1
self.rowNum = 0
elif self.statementType in (roci.OCI_STMT_INSERT,
roci.OCI_STMT_UPDATE,
roci.OCI_STMT_DELETE):
attrptr = lltype.malloc(rffi.CArrayPtr(roci.ub4).TO,
1, flavor='raw')
try:
status = roci.OCIAttrGet(
self.handle, roci.OCI_HTYPE_STMT,
rffi.cast(roci.dvoidp, attrptr),
lltype.nullptr(roci.Ptr(roci.ub4).TO),
roci.OCI_ATTR_ROW_COUNT,
self.environment.errorHandle)
self.environment.checkForError(
status, "Cursor_SetRowCount()")
self.rowCount = rffi.cast(lltype.Signed, attrptr[0])
finally:
lltype.free(attrptr, flavor='raw')
else:
self.rowCount = -1
def array_getitem(ffitype, width, addr, index, offset):
for TYPE, ffitype2 in clibffi.ffitype_map:
if ffitype is ffitype2:
addr = rffi.ptradd(addr, index * width)
addr = rffi.ptradd(addr, offset)
return rffi.cast(rffi.CArrayPtr(TYPE), addr)[0]
assert False
def _base_do_getfield_f(self, struct, fielddescr):
ofs = self.unpack_fielddescr(fielddescr)
# --- start of GC unsafe code (no GC operation!) ---
fieldptr = rffi.ptradd(rffi.cast(rffi.CCHARP, struct), ofs)
fval = rffi.cast(rffi.CArrayPtr(longlong.FLOATSTORAGE), fieldptr)[0]
# --- end of GC unsafe code ---
return fval
def bh_setarrayitem_gc_r(self, arraydescr, gcref, itemindex, newvalue):
ofs = self.unpack_arraydescr(arraydescr)
self.gc_ll_descr.do_write_barrier(gcref, newvalue)
# --- start of GC unsafe code (no GC operation!) ---
items = rffi.ptradd(rffi.cast(rffi.CCHARP, gcref), ofs)
items = rffi.cast(rffi.CArrayPtr(lltype.Signed), items)
items[itemindex] = self.cast_gcref_to_int(newvalue)
def test_insert_gcroot_marker(self):
puts = []
class FakeGcRootMap:
def put(self, retaddr, mark):
puts.append((retaddr, mark))
#
mc = BlockBuilderMixin()
mc.writechar('X')
mc.writechar('x')
mc.insert_gcroot_marker(['a', 'b', 'c', 'd'])
mc.writechar('Y')
mc.writechar('y')
mc.insert_gcroot_marker(['e', 'f', 'g'])
mc.writechar('Z')
mc.writechar('z')
#
gcrootmap = FakeGcRootMap()
allblocks = []
rawstart = mc.materialize(self.memmgr, allblocks, gcrootmap)
p = rffi.cast(rffi.CArrayPtr(lltype.Char), rawstart)
assert p[0] == 'X'
assert p[1] == 'x'
assert p[2] == 'Y'
assert p[3] == 'y'
assert p[4] == 'Z'
assert p[5] == 'z'
assert allblocks == [(rawstart, rawstart + 6)]
assert puts == [(rawstart + 2, ['a', 'b', 'c', 'd']),
(rawstart + 4, ['e', 'f', 'g'])]
def main(n):
with lltype.scoped_alloc(rffi.CArray(POINT), n) as points:
with lltype.scoped_alloc(rffi.CArray(POINT),
1) as result_point:
for i in xrange(n):
points[i].x = i * 2
points[i].y = i * 2 + 1
points = rffi.cast(rffi.CArrayPtr(lltype.Char), points)
result_point[0].x = 0
result_point[0].y = 0
result_point = rffi.cast(rffi.CArrayPtr(lltype.Char),
result_point)
f(points, result_point, n)
result_point = rffi.cast(rffi.CArrayPtr(POINT),
result_point)
return result_point[0].x * result_point[0].y
def _base_do_getfield_r(self, struct, fielddescr):
ofs = self.unpack_fielddescr(fielddescr)
# --- start of GC unsafe code (no GC operation!) ---
fieldptr = rffi.ptradd(rffi.cast(rffi.CCHARP, struct), ofs)
pval = rffi.cast(rffi.CArrayPtr(lltype.Signed), fieldptr)[0]
pval = self._cast_int_to_gcref(pval)
# --- end of GC unsafe code ---
return pval
def bh_getarrayitem_gc_f(self, arraydescr, gcref, itemindex):
ofs = self.unpack_arraydescr(arraydescr)
# --- start of GC unsafe code (no GC operation!) ---
items = rffi.ptradd(rffi.cast(rffi.CCHARP, gcref), ofs)
items = rffi.cast(rffi.CArrayPtr(longlong.FLOATSTORAGE), items)
fval = items[itemindex]
# --- end of GC unsafe code ---
return fval
def bh_getarrayitem_gc_r(self, arraydescr, gcref, itemindex):
ofs = self.unpack_arraydescr(arraydescr)
# --- start of GC unsafe code (no GC operation!) ---
items = rffi.ptradd(rffi.cast(rffi.CCHARP, gcref), ofs)
items = rffi.cast(rffi.CArrayPtr(lltype.Signed), items)
pval = self._cast_int_to_gcref(items[itemindex])
# --- end of GC unsafe code ---
return pval
def gc_malloc_unicode(self, num_elem):
basesize, itemsize, ofs_length = symbolic.get_array_token(
rstr.UNICODE, self.translate_support_code)
size = basesize + num_elem * itemsize
res = self.funcptr_for_new(size)
rffi.cast(rffi.CArrayPtr(lltype.Signed),
res)[ofs_length / WORD] = num_elem
return res
def do_unicodesetitem(self, stringbox, indexbox, vbox):
basesize, itemsize, ofs_length = symbolic.get_array_token(
rstr.UNICODE, self.translate_support_code)
index = indexbox.getint()
v = vbox.getint()
a = stringbox.getref_base()
basesize = basesize // itemsize
rffi.cast(rffi.CArrayPtr(lltype.UniChar),
a)[index + basesize] = unichr(v)
def _base_do_setfield_r(self, struct, fielddescr, newvalue):
ofs = self.unpack_fielddescr(fielddescr)
assert lltype.typeOf(struct) is not lltype.Signed, (
"can't handle write barriers for setfield_raw")
self.gc_ll_descr.do_write_barrier(struct, newvalue)
# --- start of GC unsafe code (no GC operation!) ---
fieldptr = rffi.ptradd(rffi.cast(rffi.CCHARP, struct), ofs)
fieldptr = rffi.cast(rffi.CArrayPtr(lltype.Signed), fieldptr)
fieldptr[0] = self.cast_gcref_to_int(newvalue)
def bh_getarrayitem_gc_i(self, arraydescr, gcref, itemindex):
ofs, size, sign = self.unpack_arraydescr_size(arraydescr)
# --- start of GC unsafe code (no GC operation!) ---
items = rffi.ptradd(rffi.cast(rffi.CCHARP, gcref), ofs)
for STYPE, UTYPE, itemsize in unroll_basic_sizes:
if size == itemsize:
if sign:
items = rffi.cast(rffi.CArrayPtr(STYPE), items)
val = items[itemindex]
val = rffi.cast(lltype.Signed, val)
else:
items = rffi.cast(rffi.CArrayPtr(UTYPE), items)
val = items[itemindex]
val = rffi.cast(lltype.Signed, val)
# --- end of GC unsafe code ---
return val
else:
raise NotImplementedError("size = %d" % size)
def _base_do_getfield_i(self, struct, fielddescr):
ofs, size, sign = self.unpack_fielddescr_size(fielddescr)
# --- start of GC unsafe code (no GC operation!) ---
fieldptr = rffi.ptradd(rffi.cast(rffi.CCHARP, struct), ofs)
for STYPE, UTYPE, itemsize in unroll_basic_sizes:
if size == itemsize:
# Note that in the common case where size==sizeof(Signed),
# both cases of what follows are doing the same thing.
# But gcc is clever enough to figure this out :-)
if sign:
val = rffi.cast(rffi.CArrayPtr(STYPE), fieldptr)[0]
val = rffi.cast(lltype.Signed, val)
else:
val = rffi.cast(rffi.CArrayPtr(UTYPE), fieldptr)[0]
val = rffi.cast(lltype.Signed, val)
# --- end of GC unsafe code ---
return val
else:
raise NotImplementedError("size = %d" % size)
def bh_setinteriorfield_gc_f(self, gcref, itemindex, descr, newvalue):
assert isinstance(descr, InteriorFieldDescr)
arraydescr = descr.arraydescr
ofs, size, _ = self.unpack_arraydescr_size(arraydescr)
ofs += descr.fielddescr.offset
# --- start of GC unsafe code (no GC operation!) ---
items = rffi.ptradd(rffi.cast(rffi.CCHARP, gcref),
ofs + size * itemindex)
items = rffi.cast(rffi.CArrayPtr(longlong.FLOATSTORAGE), items)
items[0] = newvalue
def malloc_array(basesize, num_elem, itemsize, ofs_length):
try:
totalsize = ovfcheck(basesize + ovfcheck(itemsize * num_elem))
except OverflowError:
return lltype.nullptr(llmemory.GCREF.TO)
res = self.malloc_fn_ptr(totalsize)
if res:
arrayptr = rffi.cast(rffi.CArrayPtr(lltype.Signed), res)
arrayptr[ofs_length/WORD] = num_elem
return res
