def _realize_c_struct_or_union(ffi, sindex): s = ffi.ctxobj.ctx.c_struct_unions[sindex] type_index = rffi.getintfield(s, 'c_type_index') if ffi.cached_types[type_index] is not None: return ffi.cached_types[type_index] #found already in the "primary" slot space = ffi.space w_ctype = None c_flags = rffi.getintfield(s, 'c_flags') c_first_field_index = rffi.getintfield(s, 'c_first_field_index') if (c_flags & cffi_opcode.F_EXTERNAL) == 0: if (c_flags & cffi_opcode.F_UNION) != 0: name = _realize_name("union ", s.c_name) x = ctypestruct.W_CTypeUnion(space, name) else: name = _realize_name("struct ", s.c_name) x = ctypestruct.W_CTypeStruct(space, name) if (c_flags & cffi_opcode.F_OPAQUE) == 0: assert c_first_field_index >= 0 w_ctype = x w_ctype.size = rffi.getintfield(s, 'c_size') w_ctype.alignment = rffi.getintfield(s, 'c_alignment') # w_ctype._field_list and other underscore fields are still # None, making it a "lazy" (i.e. "non-forced") kind of struct w_ctype._lazy_ffi = ffi w_ctype._lazy_s = s else: assert c_first_field_index < 0 else: assert c_first_field_index < 0 x = _fetch_external_struct_or_union(s, ffi.included_ffis_libs) if x is None: raise oefmt(ffi.w_FFIError, "'%s %s' should come from ffi.include() but was not found", "union" if c_flags & cffi_opcode.F_UNION else "struct", rffi.charp2str(s.c_name)) assert isinstance(x, ctypestruct.W_CTypeStructOrUnion) if (c_flags & cffi_opcode.F_OPAQUE) == 0 and x.size < 0: prefix = "union" if c_flags & cffi_opcode.F_UNION else "struct" name = rffi.charp2str(s.c_name) raise oefmt(space.w_NotImplementedError, "'%s %s' is opaque in the ffi.include(), but no " "longer in the ffi doing the include (workaround: don't " "use ffi.include() but duplicate the declarations of " "everything using %s %s)", prefix, name, prefix, name) # Update the "primary" OP_STRUCT_UNION slot ffi.cached_types[type_index] = x if w_ctype is not None and rffi.getintfield(s, 'c_size') == -2: # oops, this struct is unnamed and we couldn't generate # a C expression to get its size. We have to rely on # complete_struct_or_union() to compute it now. try: do_realize_lazy_struct(w_ctype) except: ffi.cached_types[type_index] = None raise return x
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. Most uses of this function should be using PyModule_Create() instead; only use this if you are sure you need it.""" modname = rffi.charp2str(module.c_m_name) if module.c_m_doc: doc = rffi.charp2str(module.c_m_doc) else: doc = None methods = module.c_m_methods state = space.fromcache(State) f_name, f_path = state.package_context if f_name is not None: modname = f_name w_mod = space.wrap(Module(space, space.wrap(modname))) state.package_context = None, None if f_path is not None: dict_w = {'__file__': space.wrap(f_path)} else: dict_w = {} convert_method_defs(space, dict_w, methods, None, w_mod, modname) for key, w_value in dict_w.items(): space.setattr(w_mod, space.wrap(key), w_value) if doc: space.setattr(w_mod, space.wrap("__doc__"), space.wrap(doc)) return w_mod
def _Py_InitPyPyModule(space, name, methods, doc, w_self, apiver): """ Create a new module object based on a name and table of functions, returning the new module object. If doc is non-NULL, it will be used to define the docstring for the module. If self is non-NULL, it will passed to the functions of the module as their (otherwise NULL) first parameter. (This was added as an experimental feature, and there are no known uses in the current version of Python.) For apiver, the only value which should be passed is defined by the constant PYTHON_API_VERSION. Note that the name parameter is actually ignored, and the module name is taken from the package_context attribute of the cpyext.State in the space cache. CPython includes some extra checking here to make sure the module being initialized lines up with what's expected, but we don't. """ from pypy.module.cpyext.typeobjectdefs import PyTypeObjectPtr modname = rffi.charp2str(name) state = space.fromcache(State) f_name, f_path = state.package_context if f_name is not None: modname = f_name w_mod = PyImport_AddModule(space, modname) state.package_context = None, None if f_path is not None: dict_w = {'__file__': space.wrap(f_path)} else: dict_w = {} convert_method_defs(space, dict_w, methods, None, w_self, modname) for key, w_value in dict_w.items(): space.setattr(w_mod, space.wrap(key), w_value) if doc: space.setattr(w_mod, space.wrap("__doc__"), space.wrap(rffi.charp2str(doc))) return w_mod # borrowed result kept alive in PyImport_AddModule()
def create_module(filename): ''' Returns the W_Module representing an LLVM module created with the contents of the given file. ''' module = llwrap.LLVMModuleCreateWithName("module") with lltype.scoped_alloc(rffi.CCHARPP.TO, 1) as out_message: with lltype.scoped_alloc(rffi.VOIDP.TO, 1) as mem_buff: with lltype.scoped_alloc(rffi.VOIDPP.TO, 1) as mem_buff_ptr: mem_buff_ptr[0] = mem_buff rc = llwrap.LLVMCreateMemoryBufferWithContentsOfFile(filename, mem_buff_ptr, out_message) if rc != 0: print "[ERROR]: Cannot create memory buffer with contents of"\ " %s: %s.\n" % (filename, rffi.charp2str(out_message[0])) raise InvalidFileException(filename) mem_buff = mem_buff_ptr[0] with lltype.scoped_alloc(rffi.VOIDPP.TO, 1) as module_ptr: module_ptr[0] = module rc = llwrap.LLVMParseBitcode(mem_buff, module_ptr, out_message) if rc != 0: print "[ERROR]: Cannot parse %s: %s.\n" % (filename, rffi.charp2str(out_message[0])) raise UnparsableBitcodeException(filename) module = module_ptr[0] return W_Module(module)
def PyCodec_IncrementalEncoder(space, encoding, errors): w_codec = interp_codecs.lookup_codec(space, rffi.charp2str(encoding)) if errors: w_errors = space.wrap(rffi.charp2str(errors)) return space.call_method(w_codec, "incrementalencoder", w_errors) else: return space.call_method(w_codec, "incrementalencoder")
def test_encode_decimal(self, space, api): with rffi.scoped_unicode2wcharp(u' (12, 35 ABC)') as u: with rffi.scoped_alloc_buffer(20) as buf: res = api.PyUnicode_EncodeDecimal(u, 13, buf.raw, None) s = rffi.charp2str(buf.raw) assert res == 0 assert s == ' (12, 35 ABC)' with rffi.scoped_unicode2wcharp(u' (12, \u1234\u1235)') as u: with rffi.scoped_alloc_buffer(20) as buf: res = api.PyUnicode_EncodeDecimal(u, 9, buf.raw, None) assert res == -1 api.PyErr_Clear() with rffi.scoped_unicode2wcharp(u' (12, \u1234\u1235)') as u: with rffi.scoped_alloc_buffer(20) as buf: with rffi.scoped_str2charp("replace") as errors: res = api.PyUnicode_EncodeDecimal(u, 9, buf.raw, errors) s = rffi.charp2str(buf.raw) assert res == 0 assert s == " (12, ??)" with rffi.scoped_unicode2wcharp(u'12\u1234') as u: with rffi.scoped_alloc_buffer(20) as buf: with rffi.scoped_str2charp("xmlcharrefreplace") as errors: res = api.PyUnicode_EncodeDecimal(u, 3, buf.raw, errors) s = rffi.charp2str(buf.raw) assert res == 0 assert s == "12ሴ"
def __init__(self, space, pto): bases_w = space.fixedview(from_ref(space, pto.c_tp_bases)) dict_w = {} add_operators(space, dict_w, pto) convert_method_defs(space, dict_w, pto.c_tp_methods, self) convert_getset_defs(space, dict_w, pto.c_tp_getset, self) convert_member_defs(space, dict_w, pto.c_tp_members, self) name = rffi.charp2str(pto.c_tp_name) flag_heaptype = pto.c_tp_flags & Py_TPFLAGS_HEAPTYPE if flag_heaptype: minsize = rffi.sizeof(PyHeapTypeObject.TO) else: minsize = rffi.sizeof(PyObject.TO) new_layout = (pto.c_tp_basicsize > minsize or pto.c_tp_itemsize > 0) W_TypeObject.__init__(self, space, name, bases_w or [space.w_object], dict_w, force_new_layout=new_layout, is_heaptype=flag_heaptype) self.flag_cpytype = True # if a sequence or a mapping, then set the flag to force it if pto.c_tp_as_sequence and pto.c_tp_as_sequence.c_sq_item: self.flag_map_or_seq = 'S' elif (pto.c_tp_as_mapping and pto.c_tp_as_mapping.c_mp_subscript and not (pto.c_tp_as_sequence and pto.c_tp_as_sequence.c_sq_slice)): self.flag_map_or_seq = 'M' if pto.c_tp_doc: self.w_doc = space.wrap(rffi.charp2str(pto.c_tp_doc))
def getdefaultlocale(): encoding = "cp%d" % GetACP() BUFSIZE = 50 buf_lang = lltype.malloc(rffi.CCHARP.TO, BUFSIZE, flavor='raw') buf_country = lltype.malloc(rffi.CCHARP.TO, BUFSIZE, flavor='raw') try: if (GetLocaleInfo(cConfig.LOCALE_USER_DEFAULT, cConfig.LOCALE_SISO639LANGNAME, buf_lang, BUFSIZE) and GetLocaleInfo(cConfig.LOCALE_USER_DEFAULT, cConfig.LOCALE_SISO3166CTRYNAME, buf_country, BUFSIZE)): lang = rffi.charp2str(buf_lang) country = rffi.charp2str(buf_country) language = "%s_%s" % (lang, country) # If we end up here, this windows version didn't know about # ISO639/ISO3166 names (it's probably Windows 95). Return the # Windows language identifier instead (a hexadecimal number) elif GetLocaleInfo(cConfig.LOCALE_USER_DEFAULT, cConfig.LOCALE_IDEFAULTLANGUAGE, buf_lang, BUFSIZE): lang = rffi.charp2str(buf_lang) language = "0x%s" % (lang,) else: language = None finally: lltype.free(buf_lang, flavor='raw') lltype.free(buf_country, flavor='raw') return language, encoding
def descr_list_types(self): """\ Returns the user type names known to this FFI instance. This returns a tuple containing three lists of names: (typedef_names, names_of_structs, names_of_unions)""" # space = self.space ctx = self.ctxobj.ctx lst1_w = [] for i in range(rffi.getintfield(ctx, "c_num_typenames")): s = rffi.charp2str(ctx.c_typenames[i].c_name) lst1_w.append(space.wrap(s)) lst2_w = [] lst3_w = [] for i in range(rffi.getintfield(ctx, "c_num_struct_unions")): su = ctx.c_struct_unions[i] if su.c_name[0] == "$": continue s = rffi.charp2str(su.c_name) if rffi.getintfield(su, "c_flags") & cffi_opcode.F_UNION: lst_w = lst3_w else: lst_w = lst2_w lst_w.append(space.wrap(s)) return space.newtuple([space.newlist(lst1_w), space.newlist(lst2_w), space.newlist(lst3_w)])
def PyUnicode_FromEncodedObject(space, w_obj, encoding, errors): """Coerce an encoded object obj to an Unicode object and return a reference with incremented refcount. String and other char buffer compatible objects are decoded according to the given encoding and using the error handling defined by errors. Both can be NULL to have the interface use the default values (see the next section for details). All other objects, including Unicode objects, cause a TypeError to be set.""" if not encoding: raise oefmt(space.w_TypeError, "decoding Unicode is not supported") w_encoding = space.wrap(rffi.charp2str(encoding)) if errors: w_errors = space.wrap(rffi.charp2str(errors)) else: w_errors = None # - unicode is disallowed # - raise TypeError for non-string types if space.isinstance_w(w_obj, space.w_unicode): w_meth = None else: try: w_meth = space.getattr(w_obj, space.wrap('decode')) except OperationError as e: if not e.match(space, space.w_AttributeError): raise w_meth = None if w_meth is None: raise oefmt(space.w_TypeError, "decoding Unicode is not supported") return space.call_function(w_meth, w_encoding, w_errors)
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 copy 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 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 PyFile_FromString(space, filename, mode): """ On success, return a new file object that is opened on the file given by filename, with a file mode given by mode, where mode has the same semantics as the standard C routine fopen(). On failure, return NULL.""" w_filename = space.wrap(rffi.charp2str(filename)) w_mode = space.wrap(rffi.charp2str(mode)) return space.call_method(space.builtin, 'file', w_filename, w_mode)
def _realize_name(prefix, charp_src_name): # "xyz" => "struct xyz" # "$xyz" => "xyz" # "$1" => "struct $1" if charp_src_name[0] == "$" and charp_src_name[1] != "$" and not ("0" <= charp_src_name[1] <= "9"): return rffi.charp2str(rffi.ptradd(charp_src_name, 1)) else: return prefix + rffi.charp2str(charp_src_name)
def _realize_name(prefix, charp_src_name): # "xyz" => "struct xyz" # "$xyz" => "xyz" # "$1" => "struct $1" if (charp_src_name[0] == '$' and charp_src_name[1] != '$' and not ('0' <= charp_src_name[1] <= '9')): return rffi.charp2str(rffi.ptradd(charp_src_name, 1)) else: return prefix + rffi.charp2str(charp_src_name)
def _ssl_seterror(space, ss, ret): assert ret <= 0 if ss is None: errval = libssl_ERR_peek_last_error() errstr = rffi.charp2str(libssl_ERR_error_string(errval, None)) return ssl_error(space, errstr, errval) elif ss.ssl: err = libssl_SSL_get_error(ss.ssl, ret) else: err = SSL_ERROR_SSL errstr = "" errval = 0 if err == SSL_ERROR_ZERO_RETURN: errstr = "TLS/SSL connection has been closed" errval = PY_SSL_ERROR_ZERO_RETURN elif err == SSL_ERROR_WANT_READ: errstr = "The operation did not complete (read)" errval = PY_SSL_ERROR_WANT_READ elif err == SSL_ERROR_WANT_WRITE: errstr = "The operation did not complete (write)" errval = PY_SSL_ERROR_WANT_WRITE elif err == SSL_ERROR_WANT_X509_LOOKUP: errstr = "The operation did not complete (X509 lookup)" errval = PY_SSL_ERROR_WANT_X509_LOOKUP elif err == SSL_ERROR_WANT_CONNECT: errstr = "The operation did not complete (connect)" errval = PY_SSL_ERROR_WANT_CONNECT elif err == SSL_ERROR_SYSCALL: e = libssl_ERR_get_error() if e == 0: if ret == 0 or space.is_w(ss.w_socket, space.w_None): errstr = "EOF occurred in violation of protocol" errval = PY_SSL_ERROR_EOF elif ret == -1: # the underlying BIO reported an I/0 error error = rsocket.last_error() return interp_socket.converted_error(space, error) else: errstr = "Some I/O error occurred" errval = PY_SSL_ERROR_SYSCALL else: errstr = rffi.charp2str(libssl_ERR_error_string(e, None)) errval = PY_SSL_ERROR_SYSCALL elif err == SSL_ERROR_SSL: e = libssl_ERR_get_error() errval = PY_SSL_ERROR_SSL if e != 0: errstr = rffi.charp2str(libssl_ERR_error_string(e, None)) else: errstr = "A failure in the SSL library occurred" else: errstr = "Invalid error code" errval = PY_SSL_ERROR_INVALID_ERROR_CODE return ssl_error(space, errstr, errval)
def _unpack_fields(entry): if not entry.c_name: return None name = rffi.charp2str(entry.c_name) _type = int(entry.c_type) offset = float(entry.c_gmtoffset) fullname = "" if entry.c_full_tz_name: fullname = rffi.charp2str(entry.c_full_tz_name) return TzAbbrEntry(name, _type, offset, fullname)
def _build_user_info(space, res): return space.new_array_from_pairs([ (space.newstr("name"), space.newstr(rffi.charp2str(res.c_pw_name))), (space.newstr("passwd"), space.newstr(rffi.charp2str(res.c_pw_passwd))), (space.newstr("uid"), space.newint(intmask(res.c_pw_uid))), (space.newstr("gid"), space.newint(intmask(res.c_pw_gid))), (space.newstr("gecos"), space.newstr(rffi.charp2str(res.c_pw_gecos))), (space.newstr("dir"), space.newstr(rffi.charp2str(res.c_pw_dir))), (space.newstr("shell"), space.newstr(rffi.charp2str(res.c_pw_shell))), ])
def _build_group_info(space, res): members = [] for member in rffi.charpp2liststr(res.c_gr_mem): members.append(space.newstr(member)) return space.new_array_from_pairs([ (space.newstr("name"), space.newstr(rffi.charp2str(res.c_gr_name))), (space.newstr("passwd"), space.newstr(rffi.charp2str(res.c_gr_passwd))), (space.newstr("members"), space.new_array_from_list(members)), (space.newstr("gid"), space.newint(intmask(res.c_gr_gid))), ])
def _get_common_types(space, w_dict): from pypy.module._cffi_backend.parse_c_type import ll_enum_common_types index = 0 while True: p = ll_enum_common_types(rffi.cast(rffi.INT, index)) if not p: break key = rffi.charp2str(p) value = rffi.charp2str(rffi.ptradd(p, len(key) + 1)) space.setitem_str(w_dict, key, space.wrap(value)) index += 1
def PyImport_ExecCodeModuleEx(space, name, w_code, pathname): """Like PyImport_ExecCodeModule(), but the __file__ attribute of the module object is set to pathname if it is non-NULL.""" code = space.interp_w(PyCode, w_code) w_name = space.wrap(rffi.charp2str(name)) if pathname: pathname = rffi.charp2str(pathname) else: pathname = code.co_filename w_mod = importing.add_module(space, w_name) space.setattr(w_mod, space.wrap('__file__'), space.wrap(pathname)) return importing.exec_code_module(space, w_mod, code, w_name)
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, tag="cpyext_1")
def PyFile_FromFile(space, fp, name, mode, close): """Create a new PyFileObject from the already-open standard C file pointer, fp. The function close will be called when the file should be closed. Return NULL on failure.""" if close: raise oefmt(space.w_NotImplementedError, 'PyFromFile(..., close) with close function not implemented') w_ret = space.allocate_instance(W_File, space.gettypefor(W_File)) w_ret.w_name = space.wrap(rffi.charp2str(name)) w_ret.check_mode_ok(rffi.charp2str(mode)) w_ret.fp = fp return w_ret
def _get_timezone(interp, this): zone_type = rffi.cast(lltype.Signed, this.timelib_time.c_zone_type) if zone_type == timelib.ZONETYPE_ID: return interp.space.wrap( rffi.charp2str(this.timezone.timelib_timezone.c_name) ) elif zone_type == timelib.ZONETYPE_ABBR: return interp.space.wrap( rffi.charp2str(this.timelib_time.c_tz_abbr) ) elif zone_type == timelib.ZONETYPE_OFFSET: pass
def PyUnicode_Decode(space, s, size, encoding, errors): """Create a Unicode object by decoding size bytes of the encoded string s. encoding and errors have the same meaning as the parameters of the same name in the unicode() built-in function. The codec to be used is looked up using the Python codec registry. Return NULL if an exception was raised by the codec.""" w_str = space.wrap(rffi.charpsize2str(s, size)) w_encoding = space.wrap(rffi.charp2str(encoding)) if errors: w_errors = space.wrap(rffi.charp2str(errors)) else: w_errors = space.w_None return space.call_method(w_str, 'decode', w_encoding, w_errors)
def __init__(self, member, w_type): self.member = member self.name = rffi.charp2str(member.c_name) self.w_type = w_type flags = rffi.cast(lltype.Signed, member.c_flags) doc = set = None if member.c_doc: doc = rffi.charp2str(member.c_doc) get = GettersAndSetters.member_getter.im_func del_ = GettersAndSetters.member_delete.im_func if not (flags & structmemberdefs.READONLY): set = GettersAndSetters.member_setter.im_func GetSetProperty.__init__(self, get, set, del_, doc, cls=None, use_closure=True, tag="cpyext_2")
def make_struct_passwd(space, pw): w_passwd_struct = space.getattr(space.getbuiltinmodule('pwd'), space.wrap('struct_passwd')) w_tuple = space.newtuple([ space.wrap(rffi.charp2str(pw.c_pw_name)), space.wrap(rffi.charp2str(pw.c_pw_passwd)), space.int(space.wrap(pw.c_pw_uid)), space.int(space.wrap(pw.c_pw_gid)), space.wrap(rffi.charp2str(pw.c_pw_gecos)), space.wrap(rffi.charp2str(pw.c_pw_dir)), space.wrap(rffi.charp2str(pw.c_pw_shell)), ]) return space.call_function(w_passwd_struct, w_tuple)
def PyUnicode_AsEncodedObject(space, w_unicode, llencoding, llerrors): """Encode a Unicode object and return the result as Python object. encoding and errors have the same meaning as the parameters of the same name in the Unicode encode() method. The codec to be used is looked up using the Python codec registry. Return NULL if an exception was raised by the codec.""" if not PyUnicode_Check(space, w_unicode): PyErr_BadArgument(space) encoding = errors = None if llencoding: encoding = rffi.charp2str(llencoding) if llerrors: errors = rffi.charp2str(llerrors) return unicodeobject.encode_object(space, w_unicode, encoding, errors)
def Py_CompileStringFlags(space, source, filename, start, flagsptr): """Parse and compile the Python source code in str, returning the resulting code object. The start token is given by start; this can be used to constrain the code which can be compiled and should be Py_eval_input, Py_file_input, or Py_single_input. The filename specified by filename is used to construct the code object and may appear in tracebacks or SyntaxError exception messages. This returns NULL if the code cannot be parsed or compiled.""" source = rffi.charp2str(source) filename = rffi.charp2str(filename) if flagsptr: flags = rffi.cast(lltype.Signed, flagsptr.c_cf_flags) else: flags = 0 return compile_string(space, source, filename, start, flags)
def getnameinfo(address, flags): host = lltype.malloc(rffi.CCHARP.TO, NI_MAXHOST, flavor="raw") try: serv = lltype.malloc(rffi.CCHARP.TO, NI_MAXSERV, flavor="raw") try: addr = address.lock() error = intmask(_c.getnameinfo(addr, address.addrlen, host, NI_MAXHOST, serv, NI_MAXSERV, flags)) address.unlock() if error: raise GAIError(error) return rffi.charp2str(host), rffi.charp2str(serv) finally: lltype.free(serv, flavor="raw") finally: lltype.free(host, flavor="raw")
def test_frombuffer(self, space, api): w_view = SimpleView(StringBuffer("hello")).wrap(space) w_memoryview = api.PyMemoryView_FromObject(w_view) c_memoryview = rffi.cast(PyMemoryViewObject, make_ref(space, w_memoryview)) view = c_memoryview.c_view assert view.c_ndim == 1 f = rffi.charp2str(view.c_format) assert f == 'B' assert view.c_shape[0] == 5 assert view.c_strides[0] == 1 assert view.c_len == 5 o = rffi.charp2str(view.c_buf) assert o == 'hello' ref = api.PyMemoryView_FromBuffer(view) w_mv = from_ref(space, ref) for f in ('format', 'itemsize', 'ndim', 'readonly', 'shape', 'strides', 'suboffsets'): w_f = space.wrap(f) assert space.eq_w(space.getattr(w_mv, w_f), space.getattr(w_memoryview, w_f)) decref(space, ref) decref(space, c_memoryview)
def load_embedded_cffi_module(space, version, init_struct): from pypy.module._cffi_backend.cffi1_module import load_cffi1_module declare_c_function() # translation-time hint only: # declare _cffi_carefully_make_gil() # version = rffi.cast(lltype.Signed, version) if not (EMBED_VERSION_MIN <= version <= EMBED_VERSION_MAX): raise oefmt(space.w_ImportError, "cffi embedded module has got unknown version tag %s", hex(version)) # if space.config.objspace.usemodules.thread: from pypy.module.thread import os_thread os_thread.setup_threads(space) # name = rffi.charp2str(init_struct.name) load_cffi1_module(space, name, None, init_struct.func) code = rffi.charp2str(init_struct.code) compiler = space.createcompiler() pycode = compiler.compile(code, "<init code for '%s'>" % name, 'exec', 0) w_globals = space.newdict(module=True) space.setitem_str(w_globals, "__builtins__", space.builtin) pycode.exec_code(space, w_globals, w_globals)
def PyErr_SetFromErrnoWithFilename(space, w_type, llfilename): """Similar to PyErr_SetFromErrno(), with the additional behavior that if filename is not NULL, it is passed to the constructor of type as a third parameter. In the case of exceptions such as IOError and OSError, this is used to define the filename attribute of the exception instance. Return value: always NULL.""" # XXX Doesn't actually do anything with PyErr_CheckSignals. if llfilename: w_filename = rffi.charp2str(llfilename) filename = space.wrap(w_filename) else: filename = space.w_None PyErr_SetFromErrnoWithFilenameObject(space, w_type, filename)
def realpath(path): path = pathobj.os_stringify(path).encode('utf-8') req = lltype.malloc(uv.fs_ptr.TO, flavor='raw', zero=True) try: response = uv_callback.fs(req) response.wait( uv.fs_realpath(response.ec.uv_loop, req, path, uv_callback.fs.cb)) if req.c_result < 0: raise uv_callback.to_error(req.c_result) # hmm? return from_cstring(rffi.charp2str(rffi.cast(rffi.CCHARP, req.c_ptr))) finally: uv.fs_req_cleanup(req) lltype.free(req, flavor='raw')
def test_asbuffer(self, space): bufp = lltype.malloc(rffi.CCHARPP.TO, 1, flavor='raw') lenp = lltype.malloc(Py_ssize_tP.TO, 1, flavor='raw') w_text = space.newbytes("text") ref = make_ref(space, w_text) prev_refcnt = ref.c_ob_refcnt assert PyObject_AsCharBuffer(space, ref, bufp, lenp) == 0 assert ref.c_ob_refcnt == prev_refcnt assert lenp[0] == 4 assert rffi.charp2str(bufp[0]) == 'text' lltype.free(bufp, flavor='raw') lltype.free(lenp, flavor='raw') decref(space, ref)
def mkdtemp(path): path = pathobj.os_stringify(path).encode('utf-8') # TODO: XXXXXX the last six characters must be these. req = lltype.malloc(uv.fs_ptr.TO, flavor='raw', zero=True) try: response = uv_callback.fs(req) response.wait( uv.fs_mkdtemp(response.ec.uv_loop, req, path, uv_callback.fs.cb)) if req.c_result < 0: raise uv_callback.to_error(req.c_result) return from_cstring(rffi.charp2str(rffi.cast(rffi.CCHARP, req.c_path))) finally: uv.fs_req_cleanup(req) lltype.free(req, flavor='raw')
def localeconv(space): "() -> dict. Returns numeric and monetary locale-specific parameters." lp = rlocale.localeconv() # Numeric information w_result = space.newdict() w = space.wrap space.setitem(w_result, w("decimal_point"), charp2uni(space, lp.c_decimal_point)) space.setitem(w_result, w("thousands_sep"), charp2uni(space, lp.c_thousands_sep)) space.setitem(w_result, w("grouping"), _w_copy_grouping(space, rffi.charp2str(lp.c_grouping))) space.setitem(w_result, w("int_curr_symbol"), charp2uni(space, lp.c_int_curr_symbol)) space.setitem(w_result, w("currency_symbol"), charp2uni(space, lp.c_currency_symbol)) space.setitem(w_result, w("mon_decimal_point"), charp2uni(space, lp.c_mon_decimal_point)) space.setitem(w_result, w("mon_thousands_sep"), charp2uni(space, lp.c_mon_thousands_sep)) space.setitem(w_result, w("mon_grouping"), _w_copy_grouping(space, rffi.charp2str(lp.c_mon_grouping))) space.setitem(w_result, w("positive_sign"), charp2uni(space, lp.c_positive_sign)) space.setitem(w_result, w("negative_sign"), charp2uni(space, lp.c_negative_sign)) space.setitem(w_result, w("int_frac_digits"), w(lp.c_int_frac_digits)) space.setitem(w_result, w("frac_digits"), w(lp.c_frac_digits)) space.setitem(w_result, w("p_cs_precedes"), w(lp.c_p_cs_precedes)) space.setitem(w_result, w("p_sep_by_space"), w(lp.c_p_sep_by_space)) space.setitem(w_result, w("n_cs_precedes"), w(lp.c_n_cs_precedes)) space.setitem(w_result, w("n_sep_by_space"), w(lp.c_n_sep_by_space)) space.setitem(w_result, w("p_sign_posn"), w(lp.c_p_sign_posn)) space.setitem(w_result, w("n_sign_posn"), w(lp.c_n_sign_posn)) return w_result
def __init__(self, space, pto): bases_w = space.fixedview(from_ref(space, pto.c_tp_bases)) dict_w = {} add_operators(space, dict_w, pto) convert_method_defs(space, dict_w, pto.c_tp_methods, self) convert_getset_defs(space, dict_w, pto.c_tp_getset, self) convert_member_defs(space, dict_w, pto.c_tp_members, self) w_dict = from_ref(space, pto.c_tp_dict) if w_dict is not None: dictkeys_w = space.listview(w_dict) for w_key in dictkeys_w: key = space.text_w(w_key) dict_w[key] = space.getitem(w_dict, w_key) name = rffi.charp2str(cts.cast('char*', pto.c_tp_name)) flag_heaptype = pto.c_tp_flags & Py_TPFLAGS_HEAPTYPE if flag_heaptype: minsize = rffi.sizeof(PyHeapTypeObject.TO) else: minsize = rffi.sizeof(PyObject.TO) new_layout = (pto.c_tp_basicsize > minsize or pto.c_tp_itemsize > 0) W_TypeObject.__init__(self, space, name, bases_w or [space.w_object], dict_w, force_new_layout=new_layout, is_heaptype=flag_heaptype) self.flag_cpytype = True # if a sequence or a mapping, then set the flag to force it if pto.c_tp_as_sequence and pto.c_tp_as_sequence.c_sq_item: self.flag_map_or_seq = 'S' elif (pto.c_tp_as_mapping and pto.c_tp_as_mapping.c_mp_subscript and not (pto.c_tp_as_sequence and pto.c_tp_as_sequence.c_sq_slice)): self.flag_map_or_seq = 'M' if pto.c_tp_doc: self.w_doc = space.newtext( rffi.charp2str(cts.cast('char*', pto.c_tp_doc)))
def getaddrinfo(node, service): req = lltype.malloc(uv.getaddrinfo_ptr.TO, flavor='raw', zero=True) if node is None: node_string = lltype.nullptr(rffi.CCHARP.TO) else: node_string = rffi.str2charp(node.string.encode('utf-8')) if service is None: service_string = lltype.nullptr(rffi.CCHARP.TO) else: service_string = rffi.str2charp(service.string.encode('utf-8')) try: response = uv_callback.getaddrinfo(req) status, res = response.wait( uv.getaddrinfo(response.ec.uv_loop, req, uv_callback.getaddrinfo.cb, node_string, service_string, lltype.nullptr(uv.addrinfo_ptr.TO))) if rffi.r_long(status) < 0: raise uv_callback.to_error(status) this = res result = [] while this != lltype.nullptr(uv.addrinfo_ptr.TO): entry = Exnihilo() entry.setattr(u"flags", Integer(rffi.r_long(this.c_ai_flags))) entry.setattr(u"family", Integer(rffi.r_long(this.c_ai_family))) entry.setattr(u"socktype", Integer(rffi.r_long(this.c_ai_socktype))) entry.setattr(u"protocol", Integer(rffi.r_long(this.c_ai_protocol))) entry.setattr( u"addr", copy_to_uint8array(rffi.cast(rffi.VOIDP, this.c_ai_addr), this.c_ai_addrlen, rffi.sizeof(uv.sockaddr_storage))) if this.c_ai_canonname: entry.setattr( u"canonname", from_cstring(rffi.charp2str(this.c_ai_canonname))) else: entry.setattr(u"canonname", null) result.append(entry) this = rffi.cast(uv.addrinfo_ptr, this.c_ai_next) uv.freeaddrinfo(res) return List(result) finally: if node_string: lltype.free(node_string, flavor='raw') if service_string: lltype.free(service_string, flavor='raw') lltype.free(req, flavor='raw')
def PyMember_GetOne(space, obj, w_member): addr = rffi.cast(ADDR, obj) addr += w_member.c_offset member_type = rffi.cast(lltype.Signed, w_member.c_type) for converter in integer_converters: typ, lltyp, _ = converter if typ == member_type: result = rffi.cast(rffi.CArrayPtr(lltyp), addr) if lltyp is rffi.FLOAT: w_result = space.newfloat( lltype.cast_primitive(lltype.Float, result[0])) elif typ == T_BOOL: x = rffi.cast(lltype.Signed, result[0]) w_result = space.newbool(x != 0) elif typ == T_DOUBLE: w_result = space.newfloat(result[0]) else: w_result = space.newint(result[0]) return w_result if member_type == T_STRING: result = rffi.cast(rffi.CCHARPP, addr) if result[0]: w_result = PyString_FromString(space, result[0]) else: w_result = space.w_None elif member_type == T_STRING_INPLACE: result = rffi.cast(rffi.CCHARP, addr) w_result = PyString_FromString(space, result) elif member_type == T_CHAR: result = rffi.cast(rffi.CCHARP, addr) w_result = space.newtext(result[0]) elif member_type == T_OBJECT: obj_ptr = rffi.cast(PyObjectP, addr) if obj_ptr[0]: w_result = from_ref(space, obj_ptr[0]) else: w_result = space.w_None elif member_type == T_OBJECT_EX: obj_ptr = rffi.cast(PyObjectP, addr) if obj_ptr[0]: w_result = from_ref(space, obj_ptr[0]) else: w_name = space.newtext(rffi.charp2str(w_member.c_name)) raise OperationError(space.w_AttributeError, w_name) else: raise oefmt(space.w_SystemError, "bad memberdescr type") return w_result
def _cffi_call_python(ll_externpy, ll_args): """Invoked by the helpers generated from extern "Python" in the cdef. 'externpy' is a static structure that describes which of the extern "Python" functions is called. It has got fields 'name' and 'type_index' describing the function, and more reserved fields that are initially zero. These reserved fields are set up by ffi.def_extern(), which invokes externpy_deco() below. 'args' is a pointer to an array of 8-byte entries. Each entry contains an argument. If an argument is less than 8 bytes, only the part at the beginning of the entry is initialized. If an argument is 'long double' or a struct/union, then it is passed by reference. 'args' is also used as the place to write the result to (directly, even if more than 8 bytes). In all cases, 'args' is at least 8 bytes in size. """ from pypy.module._cffi_backend.ccallback import reveal_callback from rpython.rlib import rgil rgil.acquire_maybe_in_new_thread() llop.gc_stack_bottom(lltype.Void) # marker to enter RPython from C cerrno._errno_after(rffi.RFFI_ERR_ALL | rffi.RFFI_ALT_ERRNO) if not ll_externpy.c_reserved1: # Not initialized! We don't have a space at all. # Write the error to the file descriptor stderr. try: funcname = rffi.charp2str(ll_externpy.c_name) msg = ("extern \"Python\": function %s() called, but no code was " "attached to it yet with @ffi.def_extern(). " "Returning 0.\n" % (funcname, )) os.write(STDERR, msg) except: pass for i in range(intmask(ll_externpy.c_size_of_result)): ll_args[i] = '\x00' else: externpython = reveal_callback(ll_externpy.c_reserved1) # the same buffer is used both for passing arguments and # the result value externpython.invoke(ll_args, ll_args) cerrno._errno_before(rffi.RFFI_ERR_ALL | rffi.RFFI_ALT_ERRNO) rgil.release()
def do_ufunc(space, funcs, data, types, ntypes, nin, nout, identity, name, doc, check_return, w_signature): funcs_w = [None] * ntypes dtypes_w = [None] * ntypes * (nin + nout) for i in range(ntypes): funcs_w[i] = ufuncs.W_GenericUFuncCaller(funcs[i], data) for i in range(ntypes * (nin + nout)): dtypes_w[i] = get_dtype_cache(space).dtypes_by_num(ord(types[i])) w_funcs = space.newlist(funcs_w) w_dtypes = space.newlist(dtypes_w) w_doc = rffi.charp2str(doc) w_name = rffi.charp2str(name) w_identity = space.newint(identity) ufunc_generic = ufuncs.frompyfunc(space, w_funcs, nin, nout, w_dtypes, w_signature, w_identity, w_name, w_doc, stack_inputs=True) return ufunc_generic
def PyRun_StringFlags(space, source, start, w_globals, w_locals, flagsptr): """Execute Python source code from str in the context specified by the dictionaries globals and locals with the compiler flags specified by flags. The parameter start specifies the start token that should be used to parse the source code. Returns the result of executing the code as a Python object, or NULL if an exception was raised.""" source = rffi.charp2str(source) if flagsptr: flags = rffi.cast(lltype.Signed, flagsptr.c_cf_flags) else: flags = 0 w_code = compile_string(space, source, "<string>", start, flags) return compiling.eval(space, w_code, w_globals, w_locals)
def test_unicodeobject(self, space, api): assert api.PyUnicode_GET_SIZE(space.wrap(u'späm')) == 4 assert api.PyUnicode_GetSize(space.wrap(u'späm')) == 4 unichar = rffi.sizeof(Py_UNICODE) assert api.PyUnicode_GET_DATA_SIZE(space.wrap(u'späm')) == 4 * unichar encoding = rffi.charp2str(api.PyUnicode_GetDefaultEncoding()) w_default_encoding = space.call_function( space.sys.get('getdefaultencoding')) assert encoding == space.unwrap(w_default_encoding) invalid = rffi.str2charp('invalid') utf_8 = rffi.str2charp('utf-8') prev_encoding = rffi.str2charp(space.unwrap(w_default_encoding)) self.raises(space, api, TypeError, api.PyUnicode_SetDefaultEncoding, lltype.nullptr(rffi.CCHARP.TO)) assert api.PyUnicode_SetDefaultEncoding(invalid) == -1 assert api.PyErr_Occurred() is space.w_LookupError api.PyErr_Clear() assert api.PyUnicode_SetDefaultEncoding(utf_8) == 0 assert rffi.charp2str(api.PyUnicode_GetDefaultEncoding()) == 'utf-8' assert api.PyUnicode_SetDefaultEncoding(prev_encoding) == 0 rffi.free_charp(invalid) rffi.free_charp(utf_8) rffi.free_charp(prev_encoding)
def hash_name_mapper_callback(obj_name, userdata): if not obj_name: return # Ignore aliased names, they pollute the list and OpenSSL appears # to have a its own definition of alias as the resulting list # still contains duplicate and alternate names for several # algorithms. if rffi.cast(lltype.Signed, obj_name[0].c_alias): return try: space = global_name_fetcher.space w_name = space.wrap(rffi.charp2str(obj_name[0].c_name)) global_name_fetcher.meth_names.append(w_name) except OperationError, e: global_name_fetcher.w_error = e
def UnknownEncodingHandlerData_callback(ll_userdata, name, info): id = rffi.cast(lltype.Signed, ll_userdata) userdata = global_storage.get_object(id) space = userdata.space parser = userdata.parser() name = rffi.charp2str(name) try: parser.UnknownEncodingHandler(space, name, info) except OperationError, e: if not parser._exc_info: parser._exc_info = e XML_StopParser(parser.itself, XML_FALSE) result = 0
def PyUnicode_DecodeUTF16(space, s, size, llerrors, pbyteorder): """Decode length bytes from a UTF-16 encoded buffer string and return the corresponding Unicode object. errors (if non-NULL) defines the error handling. It defaults to "strict". If byteorder is non-NULL, the decoder starts decoding using the given byte order: *byteorder == -1: little endian *byteorder == 0: native order *byteorder == 1: big endian If *byteorder is zero, and the first two bytes of the input data are a byte order mark (BOM), the decoder switches to this byte order and the BOM is not copied into the resulting Unicode string. If *byteorder is -1 or 1, any byte order mark is copied to the output (where it will result in either a \ufeff or a \ufffe character). After completion, *byteorder is set to the current byte order at the end of input data. If byteorder is NULL, the codec starts in native order mode. Return NULL if an exception was raised by the codec.""" string = rffi.charpsize2str(s, size) if pbyteorder is not None: llbyteorder = rffi.cast(lltype.Signed, pbyteorder[0]) if llbyteorder < 0: byteorder = "little" elif llbyteorder > 0: byteorder = "big" else: byteorder = "native" else: byteorder = "native" if llerrors: errors = rffi.charp2str(llerrors) else: errors = None result, _, length, byteorder = str_decode_utf_16_helper( string, errors, final=True, errorhandler=None, byteorder=byteorder) if pbyteorder is not None: pbyteorder[0] = rffi.cast(rffi.INT_real, byteorder) return space.newutf8(result, length)
def c_get_all_cpp_names(space, scope): sz = lltype.malloc(rffi.SIZE_TP.TO, 1, flavor='raw', zero=True) try: args = [_ArgH(scope.handle), _ArgP(rffi.cast(rffi.VOIDP, sz))] rawnames = rffi.cast(rffi.CCHARPP, _cdata_to_ptr(space, call_capi(space, 'get_all_cpp_names', args))) count = int(intmask(sz[0])) finally: lltype.free(sz, flavor='raw') allnames = [] for i in range(count): pystr = rffi.charp2str(rawnames[i]) c_free(space, rffi.cast(rffi.VOIDP, rawnames[i])) # c_free defined below allnames.append(pystr) c_free(space, rffi.cast(rffi.VOIDP, rawnames)) # id. return allnames
def PyLong_FromString(space, str, pend, base): """Return a new PyLongObject based on the string value in str, which is interpreted according to the radix in base. If pend is non-NULL, *pend will point to the first character in str which follows the representation of the number. If base is 0, the radix will be determined based on the leading characters of str: if str starts with '0x' or '0X', radix 16 will be used; if str starts with '0', radix 8 will be used; otherwise radix 10 will be used. If base is not 0, it must be between 2 and 36, inclusive. Leading spaces are ignored. If there are no digits, ValueError will be raised.""" s = rffi.charp2str(str) w_str = space.wrap(s) w_base = space.wrap(rffi.cast(lltype.Signed, base)) if pend: pend[0] = rffi.ptradd(str, len(s)) return space.call_function(space.w_long, w_str, w_base)
def PySequence_Fast(space, w_obj, m): """Returns the sequence o as a tuple, unless it is already a tuple or list, in which case o is returned. Use PySequence_Fast_GET_ITEM() to access the members of the result. Returns NULL on failure. If the object is not a sequence, raises TypeError with m as the message text.""" if isinstance(w_obj, listobject.W_ListObject): # make sure we can return a borrowed obj from PySequence_Fast_GET_ITEM # XXX how does this interact with CPyListStrategy? w_obj.ensure_object_strategy() return w_obj if isinstance(w_obj, tupleobject.W_TupleObject): return w_obj try: return tupleobject.W_TupleObject(space.fixedview(w_obj)) except OperationError: raise OperationError(space.w_TypeError, space.wrap(rffi.charp2str(m)))
def _getCharacterSetName(self, space, attribute): # get character set id charsetIdPtr = lltype.malloc(rffi.CArrayPtr(roci.ub2).TO, 1, flavor='raw') try: status = roci.OCIAttrGet(self.environment.handle, roci.OCI_HTYPE_ENV, rffi.cast(roci.dvoidp, charsetIdPtr), lltype.nullptr(roci.Ptr(roci.ub4).TO), attribute, self.environment.errorHandle) self.environment.checkForError( status, "Connection_GetCharacterSetName(): get charset id") charsetId = charsetIdPtr[0] finally: lltype.free(charsetIdPtr, flavor='raw') # get character set name charsetname_buf, charsetname = rffi.alloc_buffer(roci.OCI_NLS_MAXBUFSZ) try: status = roci.OCINlsCharSetIdToName(self.environment.handle, charsetname_buf, roci.OCI_NLS_MAXBUFSZ, charsetId) self.environment.checkForError( status, "Connection_GetCharacterSetName(): get Oracle charset name") ianacharset_buf, ianacharset = rffi.alloc_buffer( roci.OCI_NLS_MAXBUFSZ) try: # get IANA character set name status = roci.OCINlsNameMap(self.environment.handle, ianacharset_buf, roci.OCI_NLS_MAXBUFSZ, charsetname_buf, roci.OCI_NLS_CS_ORA_TO_IANA) self.environment.checkForError( status, "Connection_GetCharacterSetName(): translate NLS charset") charset = rffi.charp2str(ianacharset_buf) finally: rffi.keep_buffer_alive_until_here(ianacharset_buf, ianacharset) finally: rffi.keep_buffer_alive_until_here(charsetname_buf, charsetname) return space.wrap(charset)
def PyMember_SetOne(space, obj, w_member, w_value): addr = rffi.cast(ADDR, obj) addr += w_member.c_offset member_type = rffi.cast(lltype.Signed, w_member.c_type) flags = rffi.cast(lltype.Signed, w_member.c_flags) if flags & READONLY: raise oefmt(space.w_AttributeError, "readonly attribute") elif member_type in [T_STRING, T_STRING_INPLACE]: raise oefmt(space.w_TypeError, "readonly attribute") elif w_value is None: if member_type == T_OBJECT_EX: if not rffi.cast(PyObjectP, addr)[0]: w_name = space.newtext(rffi.charp2str(w_member.c_name)) raise OperationError(space.w_AttributeError, w_name) elif member_type != T_OBJECT: raise oefmt(space.w_TypeError, "can't delete numeric/char attribute") for converter in integer_converters: typ, lltyp, getter, range_checking = converter if typ == member_type: value = getter(space, w_value) array = rffi.cast(rffi.CArrayPtr(lltyp), addr) casted = rffi.cast(lltyp, value) if range_checking: if rffi.cast(lltype.typeOf(value), casted) != value: space.warn( space.newtext("structmember: truncation of value"), space.w_RuntimeWarning) array[0] = casted return 0 if member_type == T_CHAR: str_value = space.text_w(w_value) if len(str_value) != 1: raise oefmt(space.w_TypeError, "string of length 1 expected") array = rffi.cast(rffi.CCHARP, addr) array[0] = str_value[0] elif member_type in [T_OBJECT, T_OBJECT_EX]: array = rffi.cast(PyObjectP, addr) if array[0]: decref(space, array[0]) array[0] = make_ref(space, w_value) else: raise oefmt(space.w_SystemError, "bad memberdescr type") return 0
def pypy_setup_home(ll_home, verbose): from pypy.module.sys.initpath import pypy_find_stdlib verbose = rffi.cast(lltype.Signed, verbose) if ll_home and ord(ll_home[0]): home1 = rffi.charp2str(ll_home) home = join(home1, 'x') # <- so that 'll_home' can be # directly the root directory else: home1 = "pypy's shared library location" home = '*' w_path = pypy_find_stdlib(space, home) if space.is_none(w_path): if verbose: debug( "pypy_setup_home: directories 'lib-python' and 'lib_pypy'" " not found in %s or in any parent directory" % home1) return rffi.cast(rffi.INT, 1) space.startup() must_leave = space.threadlocals.try_enter_thread(space) try: # initialize sys.{path,executable,stdin,stdout,stderr} # (in unbuffered mode, to avoid troubles) and import site space.appexec([w_path, space.newtext(home), w_initstdio], r"""(path, home, initstdio): import sys # don't import anything more above this: sys.path is not set sys.path[:] = path sys.executable = home initstdio(unbuffered=True) try: import site except Exception as e: sys.stderr.write("'import site' failed:\n") import traceback traceback.print_exc() """) return rffi.cast(rffi.INT, 0) except OperationError as e: if verbose: debug("OperationError:") debug(" operror-type: " + e.w_type.getname(space)) debug(" operror-value: " + space.text_w(space.str(e.get_w_value(space)))) return rffi.cast(rffi.INT, -1) finally: if must_leave: space.threadlocals.leave_thread(space)
def wrap_getbuffer(space, w_self, w_args, func): func_target = rffi.cast(getbufferproc, func) py_obj = make_ref(space, w_self) py_type = py_obj.c_ob_type rbp = rffi.cast(rffi.VOIDP, 0) if py_type.c_tp_as_buffer: rbp = rffi.cast(rffi.VOIDP, py_type.c_tp_as_buffer.c_bf_releasebuffer) decref(space, py_obj) with lltype.scoped_alloc(Py_buffer) as pybuf: _flags = 0 if space.len_w(w_args) > 0: _flags = space.int_w(space.listview(w_args)[0]) flags = rffi.cast(rffi.INT_real, _flags) size = generic_cpy_call(space, func_target, w_self, pybuf, flags) if widen(size) < 0: space.fromcache(State).check_and_raise_exception(always=True) ptr = pybuf.c_buf size = pybuf.c_len ndim = widen(pybuf.c_ndim) shape = None if pybuf.c_shape: shape = [pybuf.c_shape[i] for i in range(ndim)] strides = None if pybuf.c_strides: strides = [pybuf.c_strides[i] for i in range(ndim)] if pybuf.c_format: format = rffi.charp2str(pybuf.c_format) else: format = 'B' # the CPython docs mandates that you do an incref whenever you call # bf_getbuffer; so, we pass needs_decref=True to ensure that we don't # leak we release the buffer: # https://docs.python.org/3.5/c-api/typeobj.html#c.PyBufferProcs.bf_getbuffer buf = CPyBuffer(space, ptr, size, w_self, format=format, ndim=ndim, shape=shape, strides=strides, itemsize=pybuf.c_itemsize, readonly=widen(pybuf.c_readonly), needs_decref=True, releasebufferproc=rbp) fq.register_finalizer(buf) return space.newbuffer(buf)
def timezone_location_get(interp, w_datetimezone): space = interp.space c_location = w_datetimezone.timelib_timezone.c_location country_code = "%s%s" % (c_location.c_country_code[0], c_location.c_country_code[1]) latitude = c_location.c_latitude longitude = c_location.c_longitude comments = rffi.charp2str(c_location.c_comments) return space.new_array_from_pairs([ (space.wrap("country_code"), space.wrap(country_code)), (space.wrap("latitude"), space.wrap(latitude)), (space.wrap("longitude"), space.wrap(longitude)), (space.wrap("comments"), space.wrap(comments)) ])
def pypy_find_stdlib(space, executable): path, prefix = None, None if executable != '*': path, prefix = find_stdlib(get_state(space), executable) if path is None: if space.config.translation.shared: dynamic_location = pypy_init_home() if dynamic_location: dyn_path = rffi.charp2str(dynamic_location) pypy_init_free(dynamic_location) path, prefix = find_stdlib(get_state(space), dyn_path) if path is None: return space.w_None w_prefix = space.newtext(prefix) space.setitem(space.sys.w_dict, space.newtext('prefix'), w_prefix) space.setitem(space.sys.w_dict, space.newtext('exec_prefix'), w_prefix) return space.newlist([space.newtext(p) for p in path])
def add_operators(space, dict_w, pto): from pypy.module.cpyext.object import PyObject_HashNotImplemented hash_not_impl = llslot(space, PyObject_HashNotImplemented) for method_name, slot_names, wrapper_class, doc in slotdefs_for_wrappers: if method_name in dict_w: continue offset = [rffi.offsetof(lltype.typeOf(pto).TO, slot_names[0])] if len(slot_names) == 1: func = getattr(pto, slot_names[0]) if slot_names[0] == 'c_tp_hash': # two special cases where __hash__ is explicitly set to None # (which leads to an unhashable type): # 1) tp_hash == PyObject_HashNotImplemented # 2) tp_hash == NULL and either of tp_compare or tp_richcompare are not NULL if hash_not_impl == func or (not func and (pto.c_tp_compare or pto.c_tp_richcompare)): dict_w[method_name] = space.w_None continue else: assert len(slot_names) == 2 struct = getattr(pto, slot_names[0]) if not struct: continue offset.append( rffi.offsetof(lltype.typeOf(struct).TO, slot_names[1])) func = getattr(struct, slot_names[1]) func_voidp = rffi.cast(rffi.VOIDP, func) if not func: continue if wrapper_class is None: continue assert issubclass(wrapper_class, W_PyCWrapperObject) w_obj = wrapper_class(space, pto, method_name, doc, func_voidp, offset=offset[:]) dict_w[method_name] = w_obj if pto.c_tp_doc: dict_w['__doc__'] = space.newtext( rffi.charp2str(cts.cast('char*', pto.c_tp_doc))) if pto.c_tp_new: add_tp_new_wrapper(space, dict_w, pto)
def ctime(space, w_seconds=None): """ctime([seconds]) -> string Convert a time in seconds since the Epoch to a string in local time. This is equivalent to asctime(localtime(seconds)). When the time tuple is not present, current time as returned by localtime() is used.""" seconds = _get_inttime(space, w_seconds) t_ref = lltype.malloc(rffi.TIME_TP.TO, 1, flavor='raw') t_ref[0] = seconds p = c_ctime(t_ref) lltype.free(t_ref, flavor='raw') if not p: raise oefmt(space.w_ValueError, "unconvertible time") return space.newtext(rffi.charp2str(p)[:-1]) # get rid of new line
def finish_type_1(space, pto): """ Sets up tp_bases, necessary before creating the interpreter type. """ base = pto.c_tp_base base_pyo = rffi.cast(PyObject, pto.c_tp_base) if base and not base.c_tp_flags & Py_TPFLAGS_READY: name = rffi.charp2str(cts.cast('char*', base.c_tp_name)) type_realize(space, base_pyo) if base and not pto.c_ob_type: # will be filled later pto.c_ob_type = base.c_ob_type if not pto.c_tp_bases: if not base: bases = space.newtuple([]) else: bases = space.newtuple([from_ref(space, base_pyo)]) pto.c_tp_bases = make_ref(space, bases)
def PySequence_Fast(space, w_obj, m): """Returns the sequence o as a tuple, unless it is already a tuple or list, in which case o is returned. Use PySequence_Fast_GET_ITEM() to access the members of the result. Returns NULL on failure. If the object cannot be converted to a sequence, and raises a TypeError, raise a new TypeError with m as the message text. If the conversion otherwise, fails, reraise the original exception""" if isinstance(w_obj, W_ListObject): # make sure we can return a borrowed obj from PySequence_Fast_GET_ITEM w_obj.convert_to_cpy_strategy(space) return w_obj try: return W_ListObject.newlist_cpyext(space, space.listview(w_obj)) except OperationError as e: if e.match(space, space.w_TypeError): raise OperationError(space.w_TypeError, space.newtext(rffi.charp2str(m))) raise e