def timelib_time_from_format(time_format_string, time_string): time_string = time_string or 'now' error = '' ll_s = rffi.str2charp(time_string) ll_format = rffi.str2charp(time_format_string) error_c = lltype.malloc(timelib_error_containerP.TO, 1, flavor='raw') ll_res = timelib_parse_from_format( ll_format, ll_s, len(time_string), error_c, timelib_builtin_db(), tzinfo_callback ) error_count = rffi.cast(lltype.Signed, error_c[0].c_error_count) if error_count: position = int(error_c[0].c_error_messages[0].c_position) message = rffi.charp2str(error_c[0].c_error_messages[0].c_message) char = error_c[0].c_error_messages[0].c_character error = "Failed to parse time string (%s) at position %s (%s): %s" % ( time_string, position, char, message ) lltype.free(error_c, flavor='raw') return ll_res, error
def test_ascii_codec(self, space, api): s = 'abcdefg' data = rffi.str2charp(s) w_u = api.PyUnicode_DecodeASCII(data, len(s), lltype.nullptr(rffi.CCHARP.TO)) assert space.eq_w(w_u, space.wrap(u"abcdefg")) rffi.free_charp(data) s = 'abcd\xFF' data = rffi.str2charp(s) self.raises(space, api, UnicodeDecodeError, api.PyUnicode_DecodeASCII, data, len(s), lltype.nullptr(rffi.CCHARP.TO)) rffi.free_charp(data) uni = u'abcdefg' data = rffi.unicode2wcharp(uni) w_s = api.PyUnicode_EncodeASCII(data, len(uni), lltype.nullptr(rffi.CCHARP.TO)) assert space.eq_w(space.wrap("abcdefg"), w_s) rffi.free_wcharp(data) u = u'äbcdéfg' data = rffi.unicode2wcharp(u) w_s = api.PyUnicode_EncodeASCII(data, len(u), lltype.nullptr(rffi.CCHARP.TO)) self.raises(space, api, UnicodeEncodeError, api.PyUnicode_EncodeASCII, data, len(u), lltype.nullptr(rffi.CCHARP.TO)) rffi.free_wcharp(data)
def strcoll(space, w_s1, w_s2): "string,string -> int. Compares two strings according to the locale." if (space.isinstance_w(w_s1, space.w_str) and space.isinstance_w(w_s2, space.w_str)): s1, s2 = space.str_w(w_s1), space.str_w(w_s2) s1_c = rffi.str2charp(s1) s2_c = rffi.str2charp(s2) try: return space.wrap(_strcoll(s1_c, s2_c)) finally: rffi.free_charp(s1_c) rffi.free_charp(s2_c) s1, s2 = space.unicode_w(w_s1), space.unicode_w(w_s2) s1_c = rffi.unicode2wcharp(s1) s2_c = rffi.unicode2wcharp(s2) try: result = _wcscoll(s1_c, s2_c) finally: rffi.free_wcharp(s1_c) rffi.free_wcharp(s2_c) return space.wrap(result)
def test_AsEncodedObject(self, space, api): ptr = space.wrap('abc') errors = rffi.str2charp("strict") encoding = rffi.str2charp("hex") res = api.PyString_AsEncodedObject( ptr, encoding, errors) assert space.unwrap(res) == "616263" res = api.PyString_AsEncodedObject( ptr, encoding, lltype.nullptr(rffi.CCHARP.TO)) assert space.unwrap(res) == "616263" rffi.free_charp(encoding) encoding = rffi.str2charp("unknown_encoding") self.raises(space, api, LookupError, api.PyString_AsEncodedObject, ptr, encoding, errors) rffi.free_charp(encoding) rffi.free_charp(errors) res = api.PyString_AsEncodedObject( ptr, lltype.nullptr(rffi.CCHARP.TO), lltype.nullptr(rffi.CCHARP.TO)) assert space.unwrap(res) == "abc" self.raises(space, api, TypeError, api.PyString_AsEncodedObject, space.wrap(2), lltype.nullptr(rffi.CCHARP.TO), lltype.nullptr(rffi.CCHARP.TO) )
def dcgettext(space, w_domain, msg, category): """dcgettext(domain, msg, category) -> string Return translation of msg in domain and category.""" if space.is_w(w_domain, space.w_None): domain = None msg_c = rffi.str2charp(msg) try: result = _dcgettext(domain, msg_c, rffi.cast(rffi.INT, category)) # note that 'result' may be the same pointer as 'msg_c', # so it must be converted to an RPython string *before* # we free msg_c. result = rffi.charp2str(result) finally: rffi.free_charp(msg_c) else: domain = space.str_w(w_domain) domain_c = rffi.str2charp(domain) msg_c = rffi.str2charp(msg) try: result = _dcgettext(domain_c, msg_c, rffi.cast(rffi.INT, category)) # note that 'result' may be the same pointer as 'msg_c', # so it must be converted to an RPython string *before* # we free msg_c. result = rffi.charp2str(result) finally: rffi.free_charp(domain_c) rffi.free_charp(msg_c) return space.wrap(result)
def strxfrm(space, s): "string -> string. Returns a string that behaves for cmp locale-aware." n1 = len(s) + 1 buf = lltype.malloc(rffi.CCHARP.TO, n1, flavor="raw", zero=True) s_c = rffi.str2charp(s) try: n2 = _strxfrm(buf, s_c, n1) + 1 finally: rffi.free_charp(s_c) if n2 > n1: # more space needed lltype.free(buf, flavor="raw") buf = lltype.malloc(rffi.CCHARP.TO, intmask(n2), flavor="raw", zero=True) s_c = rffi.str2charp(s) try: _strxfrm(buf, s_c, n2) finally: rffi.free_charp(s_c) val = rffi.charp2str(buf) lltype.free(buf, flavor="raw") return space.wrap(val)
def test_file_getline(self, space, api): filename = rffi.str2charp(str(udir / "_test_file")) mode = rffi.str2charp("w") w_file = api.PyFile_FromString(filename, mode) space.call_method(w_file, "write", space.wrap("line1\nline2\nline3\nline4")) space.call_method(w_file, "close") rffi.free_charp(mode) mode = rffi.str2charp("r") w_file = api.PyFile_FromString(filename, mode) rffi.free_charp(filename) rffi.free_charp(mode) w_line = api.PyFile_GetLine(w_file, 0) assert space.str_w(w_line) == "line1\n" w_line = api.PyFile_GetLine(w_file, 4) assert space.str_w(w_line) == "line" w_line = api.PyFile_GetLine(w_file, 0) assert space.str_w(w_line) == "2\n" # XXX We ought to raise an EOFError here, but don't w_line = api.PyFile_GetLine(w_file, -1) # assert api.PyErr_Occurred() is space.w_EOFError assert space.str_w(w_line) == "line3\n" space.call_method(w_file, "close")
def bindtextdomain(space, domain, w_dir): """bindtextdomain(domain, dir) -> string Bind the C library's domain to dir.""" if space.is_w(w_dir, space.w_None): dir = None domain_c = rffi.str2charp(domain) try: dirname = _bindtextdomain(domain_c, dir) finally: rffi.free_charp(domain_c) else: dir = space.str_w(w_dir) domain_c = rffi.str2charp(domain) dir_c = rffi.str2charp(dir) try: dirname = _bindtextdomain(domain_c, dir_c) finally: rffi.free_charp(domain_c) rffi.free_charp(dir_c) if not dirname: errno = rposix.get_saved_errno() raise OperationError(space.w_OSError, space.wrap(errno)) return space.wrap(rffi.charp2str(dirname))
def bind_textdomain_codeset(space, domain, w_codeset): """bind_textdomain_codeset(domain, codeset) -> string Bind the C library's domain to codeset.""" if space.is_w(w_codeset, space.w_None): codeset = None domain_c = rffi.str2charp(domain) try: result = _bind_textdomain_codeset(domain_c, codeset) finally: rffi.free_charp(domain_c) else: codeset = space.str_w(w_codeset) domain_c = rffi.str2charp(domain) codeset_c = rffi.str2charp(codeset) try: result = _bind_textdomain_codeset(domain_c, codeset_c) finally: rffi.free_charp(domain_c) rffi.free_charp(codeset_c) if not result: return space.w_None else: return space.wrap(rffi.charp2str(result))
def test(encoded, endian, realendian=None): encoded_charp = rffi.str2charp(encoded) strict_charp = rffi.str2charp("strict") if endian is not None: if endian < 0: value = -1 elif endian > 0: value = 1 else: value = 0 pendian = lltype.malloc(rffi.INTP.TO, 1, flavor='raw') pendian[0] = rffi.cast(rffi.INT, value) else: pendian = None w_ustr = api.PyUnicode_DecodeUTF32(encoded_charp, len(encoded), strict_charp, pendian) assert space.eq_w(space.call_method(w_ustr, 'encode', space.wrap('ascii')), space.wrap("ab")) rffi.free_charp(encoded_charp) rffi.free_charp(strict_charp) if pendian: if realendian is not None: assert rffi.cast(rffi.INT, realendian) == pendian[0] lltype.free(pendian, flavor='raw')
def load_lib(self): if not self._is_inited: load_paths = rt.deref(rt.deref(rt.load_paths)) for x in range(rt.count(load_paths)): s = rffi.str2charp(str(rt.name(rt.nth(load_paths, rt.wrap(x)))) + "/" + str(self._name)) try: self._dyn_lib = dynload.dlopen(s) self._is_inited = True except dynload.DLOpenError as ex: continue finally: rffi.free_charp(s) break if not self._is_inited: s = rffi.str2charp(str(self._name)) try: self._dyn_lib = dynload.dlopen(s) self._is_inited = True except dynload.DLOpenError as ex: raise object.runtime_error(u"Couldn't Load Library: " + self._name, u"pixie.stdlib/LibraryNotFoundException") finally: rffi.free_charp(s)
def test_newcode(self, space, api): filename = rffi.str2charp('filename') funcname = rffi.str2charp('funcname') w_code = api.PyCode_NewEmpty(filename, funcname, 3) assert w_code.co_filename == 'filename' assert w_code.co_firstlineno == 3 rffi.free_charp(filename) rffi.free_charp(funcname)
def test_dlopen(self): s = rffi.str2charp("xxxxxxxxxxxx") py.test.raises(DLOpenError, "dlopen(s)") rffi.free_charp(s) # s = rffi.str2charp(get_libc_name()) assert dlopen(s) rffi.free_charp(s)
def test_file_fromstring(self, space, api): filename = rffi.str2charp(str(udir / "_test_file")) mode = rffi.str2charp("wb") w_file = api.PyFile_FromString(filename, mode) rffi.free_charp(filename) rffi.free_charp(mode) space.call_method(w_file, "write", space.wrapbytes("text")) space.call_method(w_file, "close") assert (udir / "_test_file").read() == "text"
def test_newcode(self, space, api): filename = rffi.str2charp("filename") funcname = rffi.str2charp("funcname") w_code = api.PyCode_NewEmpty(filename, funcname, 3) assert w_code.co_filename == "filename" assert w_code.co_firstlineno == 3 ref = make_ref(space, w_code) assert "filename" == space.unwrap(from_ref(space, rffi.cast(PyCodeObject, ref).c_co_filename)) api.Py_DecRef(ref) rffi.free_charp(filename) rffi.free_charp(funcname)
def get_new_method_def(space): state = space.fromcache(State) if state.new_method_def: return state.new_method_def ptr = lltype.malloc(PyMethodDef, flavor="raw", zero=True, immortal=True) ptr.c_ml_name = rffi.cast(rffi.CONST_CCHARP, rffi.str2charp("__new__")) lltype.render_immortal(ptr.c_ml_name) rffi.setintfield(ptr, 'c_ml_flags', METH_VARARGS | METH_KEYWORDS) ptr.c_ml_doc = rffi.cast(rffi.CONST_CCHARP, rffi.str2charp( "T.__new__(S, ...) -> a new object with type S, a subtype of T")) lltype.render_immortal(ptr.c_ml_doc) state.new_method_def = ptr return ptr
def create_popen_file(command, type): ll_command = rffi.str2charp(command) try: ll_type = rffi.str2charp(type) try: ll_file = c_popen(ll_command, ll_type) if not ll_file: errno = rposix.get_saved_errno() raise OSError(errno, os.strerror(errno)) finally: lltype.free(ll_type, flavor='raw') finally: lltype.free(ll_command, flavor='raw') return RFile(ll_file, close2=_pclose2)
def get_new_method_def(space): state = space.fromcache(State) if state.new_method_def: return state.new_method_def from pypy.module.cpyext.modsupport import PyMethodDef ptr = lltype.malloc(PyMethodDef, flavor="raw", zero=True, immortal=True) ptr.c_ml_name = rffi.str2charp("__new__") lltype.render_immortal(ptr.c_ml_name) rffi.setintfield(ptr, "c_ml_flags", METH_VARARGS | METH_KEYWORDS) ptr.c_ml_doc = rffi.str2charp("T.__new__(S, ...) -> a new object with type S, a subtype of T") lltype.render_immortal(ptr.c_ml_doc) state.new_method_def = ptr return ptr
def getattr(self, space, attr): try: attribute = self.objectType.attributesByName[attr] except KeyError: msg = "ExternalObject has no attribute '%s'" %(attr,) raise OperationError(space.w_AttributeError, space.wrap(msg)) environment = self.objectType.environment scalarvalueindicatorptr = lltype.malloc(rffi.CArrayPtr(roci.OCIInd).TO, 1, flavor='raw') valueindicatorptr = lltype.malloc(rffi.CArrayPtr(roci.dvoidp).TO, 1, flavor='raw') valueptr = lltype.malloc(rffi.CArrayPtr(roci.dvoidp).TO, 1, flavor='raw') tdoptr = lltype.malloc(rffi.CArrayPtr(roci.OCIType).TO, 1, flavor='raw') nameptr = lltype.malloc(rffi.CArrayPtr(roci.oratext).TO, 1, flavor='raw') nameptr[0] = rffi.str2charp(attr) namelenptr = lltype.malloc(rffi.CArrayPtr(roci.ub4).TO, 1, flavor='raw') namelenptr[0] = rffi.cast(roci.ub4, len(attr)) try: status = roci.OCIObjectGetAttr( environment.handle, environment.errorHandle, self.instance, self.indicator, self.objectType.tdo, nameptr, namelenptr, 1, lltype.nullptr(roci.Ptr(roci.ub4).TO), 0, scalarvalueindicatorptr, valueindicatorptr, valueptr, tdoptr) environment.checkForError( status, "ExternalObject_GetAttributeValue(): getting value") # determine the proper null indicator valueIndicator = valueindicatorptr[0] if not valueIndicator: valueIndicator = rffi.cast(roci.dvoidp, scalarvalueindicatorptr) value = valueptr[0] return convertObject( space, environment, attribute.typeCode, value, valueIndicator, self, attribute.subType) finally: lltype.free(scalarvalueindicatorptr, flavor='raw') lltype.free(valueindicatorptr, flavor='raw') lltype.free(valueptr, flavor='raw') lltype.free(tdoptr, flavor='raw') rffi.free_charp(nameptr[0]) lltype.free(nameptr, flavor='raw') lltype.free(namelenptr, flavor='raw')
def get_fn_ptr(self, nm): assert isinstance(nm, unicode) self.thaw() s = rffi.str2charp(str(nm)) sym = dynload.dlsym(self._dyn_lib, s) rffi.free_charp(s) return sym
def test_dlsym(self): s = rffi.str2charp(get_libc_name()) lib = dlopen(s) rffi.free_charp(s) handle = rffi.cast(lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed)), dlsym(lib, "abs")) assert 1 == handle(1) assert 1 == handle(-1)
def test_getattr(self, space, api): charp1 = rffi.str2charp("__len__") charp2 = rffi.str2charp("not_real") assert api.PyObject_GetAttrString(space.wrap(""), charp1) assert not api.PyObject_GetAttrString(space.wrap(""), charp2) assert api.PyErr_Occurred() is space.w_AttributeError api.PyErr_Clear() assert api.PyObject_DelAttrString(space.wrap(""), charp1) == -1 assert api.PyErr_Occurred() is space.w_AttributeError api.PyErr_Clear() rffi.free_charp(charp1) rffi.free_charp(charp2) assert api.PyObject_GetAttr(space.wrap(""), space.wrap("__len__")) assert api.PyObject_DelAttr(space.wrap(""), space.wrap("__len__")) == -1 api.PyErr_Clear()
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) py_buf.c_b_offset = 0 rffi.setintfield(py_buf, 'c_b_readonly', 1) rffi.setintfield(py_buf, 'c_b_hash', -1) assert isinstance(w_obj, W_Buffer) buf = w_obj.buf if isinstance(buf, SubBuffer): py_buf.c_b_offset = buf.offset buf = buf.buffer # If buf already allocated a fixed buffer, use it, and keep a # reference to buf. # Otherwise, b_base stays NULL, and we own the b_ptr. if isinstance(buf, StringBuffer): py_buf.c_b_base = lltype.nullptr(PyObject.TO) py_buf.c_b_ptr = rffi.cast(rffi.VOIDP, rffi.str2charp(buf.value)) py_buf.c_b_size = buf.getlength() elif isinstance(buf, ArrayBuffer): w_base = buf.array py_buf.c_b_base = make_ref(space, w_base) py_buf.c_b_ptr = rffi.cast(rffi.VOIDP, buf.array._charbuf_start()) py_buf.c_b_size = buf.getlength() else: raise OperationError(space.w_NotImplementedError, space.wrap( "buffer flavor not supported"))
def PyString_AsStringAndSize(space, ref, buffer, length): if not PyString_Check(space, ref): from pypy.module.cpyext.unicodeobject import ( PyUnicode_Check, _PyUnicode_AsDefaultEncodedString) if PyUnicode_Check(space, ref): ref = _PyUnicode_AsDefaultEncodedString(space, ref, lltype.nullptr(rffi.CCHARP.TO)) else: raise oefmt(space.w_TypeError, "expected string or Unicode object, %T found", from_ref(space, ref)) ref_str = rffi.cast(PyStringObject, ref) if not ref_str.c_buffer: # copy string buffer w_str = from_ref(space, ref) s = space.str_w(w_str) ref_str.c_buffer = rffi.str2charp(s) buffer[0] = ref_str.c_buffer if length: length[0] = ref_str.c_size else: i = 0 while ref_str.c_buffer[i] != '\0': i += 1 if i != ref_str.c_size: raise OperationError(space.w_TypeError, space.wrap( "expected string without null bytes")) return 0
def test_overflow_neg(self, api): s = rffi.str2charp('-1e500') null = lltype.nullptr(rffi.CCHARPP.TO) r = api.PyOS_string_to_double(s, null, None) assert math.isinf(r) assert r < 0 rffi.free_charp(s)
def _make_mode(vm_path, path, bc, verbosity, mk_fresh): # Try to work out a plausible cached path name. dp = path.rfind(os.extsep) if dp >= 0 and os.sep not in path[dp:]: cp = path[:dp] else: cp = None if not cp or mk_fresh: return _do_make_mode(vm_path, path, None, verbosity, mk_fresh) else: # There is a cached path, so now we try and load it and see if it is upto date. If any part # of this fails, we simply go straight to full make mode. try: st = os.stat(cp) except OSError: return _do_make_mode(vm_path, path, cp, verbosity, mk_fresh) cbc, start = _read_bc(cp, "CONVEXEC") if start == -1: return _do_make_mode(vm_path, path, cp, verbosity, mk_fresh) assert start >= 0 useful_bc = cbc[start:] if Bytecode.exec_upto_date(None, rffi.str2charp(useful_bc), st.st_mtime): return cbc, start, 0 return _do_make_mode(vm_path, path, cp, verbosity, mk_fresh)
def prep_string(s): """Takes a Pixie string and returns a VoidP to that string. The string should be freed via dispose!, otherwise memory leaks could result.""" affirm(isinstance(s, String), u"Can only prep strings with prep-string") utf8 = unicode_to_utf8(rt.name(s)) raw = rffi.str2charp(utf8) return VoidP(rffi.cast(rffi.VOIDP, raw))
def parse_c_type(info, input): p_input = rffi.str2charp(input) try: res = ll_parse_c_type(info, p_input) finally: rffi.free_charp(p_input) return rffi.cast(lltype.Signed, res)
def c_stdvector_valuetype(space, pystr): cstr = rffi.str2charp(pystr) result = _c_stdvector_valuetype(cstr) rffi.free_charp(cstr) if result: return charp2str_free(space, result) return ""
def load_extension_module(space, path, name): if os.sep not in path: path = os.curdir + os.sep + path # force a '/' in the path state = space.fromcache(State) if state.find_extension(name, path) is not None: return old_context = state.package_context state.package_context = name, path try: from rpython.rlib import rdynload try: ll_libname = rffi.str2charp(path) try: dll = rdynload.dlopen(ll_libname) finally: lltype.free(ll_libname, flavor='raw') except rdynload.DLOpenError, e: raise operationerrfmt( space.w_ImportError, "unable to load extension module '%s': %s", path, e.msg) try: initptr = rdynload.dlsym(dll, 'init%s' % (name.split('.')[-1],)) except KeyError: raise operationerrfmt( space.w_ImportError, "function init%s not found in library %s", name, path) initfunc = rffi.cast(initfunctype, initptr) generic_cpy_call(space, initfunc) state.check_and_raise_exception()