Menu
▾
▴
[Jython-checkins] SF.net SVN: jython:[6276] branches/ctypes-via-rawffi/Lib
|
From: <fi...@us...> - 2009-04-29 04:39:16
|
Revision: 6276
http://jython.svn.sourceforge.net/jython/?rev=6276&view=rev
Author: fijal
Date: 2009-04-29 04:39:13 +0000 (Wed, 29 Apr 2009)
Log Message:
-----------
Copy ctypes over. Hopefully this is short-lived. The reason why I do this
is that I had to modify 3 lines in __init__.py because jython's struct
module does not support 'P' as pointer or 'O' as PyObject.
Added Paths:
-----------
branches/ctypes-via-rawffi/Lib/ctypes/
branches/ctypes-via-rawffi/Lib/ctypes/__init__.py
branches/ctypes-via-rawffi/Lib/ctypes/_endian.py
branches/ctypes-via-rawffi/Lib/ctypes/macholib/
branches/ctypes-via-rawffi/Lib/ctypes/macholib/README.ctypes
branches/ctypes-via-rawffi/Lib/ctypes/macholib/__init__.py
branches/ctypes-via-rawffi/Lib/ctypes/macholib/dyld.py
branches/ctypes-via-rawffi/Lib/ctypes/macholib/dylib.py
branches/ctypes-via-rawffi/Lib/ctypes/macholib/fetch_macholib
branches/ctypes-via-rawffi/Lib/ctypes/macholib/framework.py
branches/ctypes-via-rawffi/Lib/ctypes/test/
branches/ctypes-via-rawffi/Lib/ctypes/test/__init__.py
branches/ctypes-via-rawffi/Lib/ctypes/test/runtests.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_anon.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_array_in_pointer.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_arrays.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_as_parameter.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_bitfields.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_buffers.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_byteswap.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_callbacks.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_cast.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_cfuncs.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_checkretval.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_delattr.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_errcheck.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_find.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_funcptr.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_functions.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_incomplete.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_init.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_integers.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_internals.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_keeprefs.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_libc.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_loading.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_macholib.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_memfunctions.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_numbers.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_objects.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_parameters.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_pointers.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_prototypes.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_python_api.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_random_things.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_refcounts.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_repr.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_returnfuncptrs.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_simplesubclasses.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_sizes.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_slicing.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_stringptr.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_strings.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_struct_fields.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_structures.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_unaligned_structures.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_unicode.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_values.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_varsize_struct.py
branches/ctypes-via-rawffi/Lib/ctypes/test/test_win32.py
branches/ctypes-via-rawffi/Lib/ctypes/util.py
branches/ctypes-via-rawffi/Lib/ctypes/wintypes.py
Added: branches/ctypes-via-rawffi/Lib/ctypes/__init__.py
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/__init__.py (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/__init__.py 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,537 @@
+######################################################################
+# This file should be kept compatible with Python 2.3, see PEP 291. #
+######################################################################
+"""create and manipulate C data types in Python"""
+
+import os as _os, sys as _sys
+
+__version__ = "1.0.3"
+
+from _ctypes import Union, Structure, Array
+from _ctypes import _Pointer
+from _ctypes import CFuncPtr as _CFuncPtr
+from _ctypes import __version__ as _ctypes_version
+from _ctypes import RTLD_LOCAL, RTLD_GLOBAL
+from _ctypes import ArgumentError
+
+from struct import calcsize as _calcsize
+
+if __version__ != _ctypes_version:
+ raise Exception, ("Version number mismatch", __version__, _ctypes_version)
+
+if _os.name in ("nt", "ce"):
+ from _ctypes import FormatError
+
+DEFAULT_MODE = RTLD_LOCAL
+if _os.name == "posix" and _sys.platform == "darwin":
+ import gestalt
+
+ # gestalt.gestalt("sysv") returns the version number of the
+ # currently active system file as BCD.
+ # On OS X 10.4.6 -> 0x1046
+ # On OS X 10.2.8 -> 0x1028
+ # See also http://www.rgaros.nl/gestalt/
+ #
+ # On OS X 10.3, we use RTLD_GLOBAL as default mode
+ # because RTLD_LOCAL does not work at least on some
+ # libraries.
+
+ if gestalt.gestalt("sysv") < 0x1040:
+ DEFAULT_MODE = RTLD_GLOBAL
+
+from _ctypes import FUNCFLAG_CDECL as _FUNCFLAG_CDECL, \
+ FUNCFLAG_PYTHONAPI as _FUNCFLAG_PYTHONAPI
+
+"""
+WINOLEAPI -> HRESULT
+WINOLEAPI_(type)
+
+STDMETHODCALLTYPE
+
+STDMETHOD(name)
+STDMETHOD_(type, name)
+
+STDAPICALLTYPE
+"""
+
+def create_string_buffer(init, size=None):
+ """create_string_buffer(aString) -> character array
+ create_string_buffer(anInteger) -> character array
+ create_string_buffer(aString, anInteger) -> character array
+ """
+ if isinstance(init, (str, unicode)):
+ if size is None:
+ size = len(init)+1
+ buftype = c_char * size
+ buf = buftype()
+ buf.value = init
+ return buf
+ elif isinstance(init, (int, long)):
+ buftype = c_char * init
+ buf = buftype()
+ return buf
+ raise TypeError, init
+
+def c_buffer(init, size=None):
+## "deprecated, use create_string_buffer instead"
+## import warnings
+## warnings.warn("c_buffer is deprecated, use create_string_buffer instead",
+## DeprecationWarning, stacklevel=2)
+ return create_string_buffer(init, size)
+
+_c_functype_cache = {}
+def CFUNCTYPE(restype, *argtypes):
+ """CFUNCTYPE(restype, *argtypes) -> function prototype.
+
+ restype: the result type
+ argtypes: a sequence specifying the argument types
+
+ The function prototype can be called in different ways to create a
+ callable object:
+
+ prototype(integer address) -> foreign function
+ prototype(callable) -> create and return a C callable function from callable
+ prototype(integer index, method name[, paramflags]) -> foreign function calling a COM method
+ prototype((ordinal number, dll object)[, paramflags]) -> foreign function exported by ordinal
+ prototype((function name, dll object)[, paramflags]) -> foreign function exported by name
+ """
+ try:
+ return _c_functype_cache[(restype, argtypes)]
+ except KeyError:
+ class CFunctionType(_CFuncPtr):
+ _argtypes_ = argtypes
+ _restype_ = restype
+ _flags_ = _FUNCFLAG_CDECL
+ _c_functype_cache[(restype, argtypes)] = CFunctionType
+ return CFunctionType
+
+if _os.name in ("nt", "ce"):
+ from _ctypes import LoadLibrary as _dlopen
+ from _ctypes import FUNCFLAG_STDCALL as _FUNCFLAG_STDCALL
+ if _os.name == "ce":
+ # 'ce' doesn't have the stdcall calling convention
+ _FUNCFLAG_STDCALL = _FUNCFLAG_CDECL
+
+ _win_functype_cache = {}
+ def WINFUNCTYPE(restype, *argtypes):
+ # docstring set later (very similar to CFUNCTYPE.__doc__)
+ try:
+ return _win_functype_cache[(restype, argtypes)]
+ except KeyError:
+ class WinFunctionType(_CFuncPtr):
+ _argtypes_ = argtypes
+ _restype_ = restype
+ _flags_ = _FUNCFLAG_STDCALL
+ _win_functype_cache[(restype, argtypes)] = WinFunctionType
+ return WinFunctionType
+ if WINFUNCTYPE.__doc__:
+ WINFUNCTYPE.__doc__ = CFUNCTYPE.__doc__.replace("CFUNCTYPE", "WINFUNCTYPE")
+
+else:
+ from _ctypes import dlopen as _dlopen
+
+from _ctypes import sizeof, byref, addressof, alignment, resize
+from _ctypes import _SimpleCData
+
+def _check_size(typ, typecode=None):
+ # Check if sizeof(ctypes_type) against struct.calcsize. This
+ # should protect somewhat against a misconfigured libffi.
+ from struct import calcsize
+ if typecode is None:
+ # Most _type_ codes are the same as used in struct
+ typecode = typ._type_
+ actual, required = sizeof(typ), calcsize(typecode)
+ if actual != required:
+ raise SystemError("sizeof(%s) wrong: %d instead of %d" % \
+ (typ, actual, required))
+
+class py_object(_SimpleCData):
+ _type_ = "O"
+ def __repr__(self):
+ try:
+ return super(py_object, self).__repr__()
+ except ValueError:
+ return "%s(<NULL>)" % type(self).__name__
+#_check_size(py_object, "P")
+
+class c_short(_SimpleCData):
+ _type_ = "h"
+_check_size(c_short)
+
+class c_ushort(_SimpleCData):
+ _type_ = "H"
+_check_size(c_ushort)
+
+class c_long(_SimpleCData):
+ _type_ = "l"
+_check_size(c_long)
+
+class c_ulong(_SimpleCData):
+ _type_ = "L"
+_check_size(c_ulong)
+
+if _calcsize("i") == _calcsize("l"):
+ # if int and long have the same size, make c_int an alias for c_long
+ c_int = c_long
+ c_uint = c_ulong
+else:
+ class c_int(_SimpleCData):
+ _type_ = "i"
+ _check_size(c_int)
+
+ class c_uint(_SimpleCData):
+ _type_ = "I"
+ _check_size(c_uint)
+
+class c_float(_SimpleCData):
+ _type_ = "f"
+_check_size(c_float)
+
+class c_double(_SimpleCData):
+ _type_ = "d"
+_check_size(c_double)
+
+if _calcsize("l") == _calcsize("q"):
+ # if long and long long have the same size, make c_longlong an alias for c_long
+ c_longlong = c_long
+ c_ulonglong = c_ulong
+else:
+ class c_longlong(_SimpleCData):
+ _type_ = "q"
+ _check_size(c_longlong)
+
+ class c_ulonglong(_SimpleCData):
+ _type_ = "Q"
+ ## def from_param(cls, val):
+ ## return ('d', float(val), val)
+ ## from_param = classmethod(from_param)
+ _check_size(c_ulonglong)
+
+class c_ubyte(_SimpleCData):
+ _type_ = "B"
+c_ubyte.__ctype_le__ = c_ubyte.__ctype_be__ = c_ubyte
+# backward compatibility:
+##c_uchar = c_ubyte
+_check_size(c_ubyte)
+
+class c_byte(_SimpleCData):
+ _type_ = "b"
+c_byte.__ctype_le__ = c_byte.__ctype_be__ = c_byte
+_check_size(c_byte)
+
+class c_char(_SimpleCData):
+ _type_ = "c"
+c_char.__ctype_le__ = c_char.__ctype_be__ = c_char
+_check_size(c_char)
+
+class c_char_p(_SimpleCData):
+ _type_ = "z"
+ if _os.name == "nt":
+ def __repr__(self):
+ if not windll.kernel32.IsBadStringPtrA(self, -1):
+ return "%s(%r)" % (self.__class__.__name__, self.value)
+ return "%s(%s)" % (self.__class__.__name__, cast(self, c_void_p).value)
+ else:
+ def __repr__(self):
+ return "%s(%s)" % (self.__class__.__name__, cast(self, c_void_p).value)
+#_check_size(c_char_p, "P")
+
+class c_void_p(_SimpleCData):
+ _type_ = "P"
+c_voidp = c_void_p # backwards compatibility (to a bug)
+#_check_size(c_void_p)
+
+# This cache maps types to pointers to them.
+_pointer_type_cache = {}
+
+def POINTER(cls):
+ try:
+ return _pointer_type_cache[cls]
+ except KeyError:
+ pass
+ if type(cls) is str:
+ klass = type(_Pointer)("LP_%s" % cls,
+ (_Pointer,),
+ {})
+ _pointer_type_cache[id(klass)] = klass
+ return klass
+ else:
+ name = "LP_%s" % cls.__name__
+ klass = type(_Pointer)(name,
+ (_Pointer,),
+ {'_type_': cls})
+ _pointer_type_cache[cls] = klass
+ return klass
+
+try:
+ from _ctypes import set_conversion_mode
+except ImportError:
+ pass
+else:
+ if _os.name in ("nt", "ce"):
+ set_conversion_mode("mbcs", "ignore")
+ else:
+ set_conversion_mode("ascii", "strict")
+
+ class c_wchar_p(_SimpleCData):
+ _type_ = "Z"
+
+ class c_wchar(_SimpleCData):
+ _type_ = "u"
+
+ POINTER(c_wchar).from_param = c_wchar_p.from_param #_SimpleCData.c_wchar_p_from_param
+
+ def create_unicode_buffer(init, size=None):
+ """create_unicode_buffer(aString) -> character array
+ create_unicode_buffer(anInteger) -> character array
+ create_unicode_buffer(aString, anInteger) -> character array
+ """
+ if isinstance(init, (str, unicode)):
+ if size is None:
+ size = len(init)+1
+ buftype = c_wchar * size
+ buf = buftype()
+ buf.value = init
+ return buf
+ elif isinstance(init, (int, long)):
+ buftype = c_wchar * init
+ buf = buftype()
+ return buf
+ raise TypeError, init
+
+POINTER(c_char).from_param = c_char_p.from_param #_SimpleCData.c_char_p_from_param
+
+# XXX Deprecated
+def SetPointerType(pointer, cls):
+ if _pointer_type_cache.get(cls, None) is not None:
+ raise RuntimeError, \
+ "This type already exists in the cache"
+ if not _pointer_type_cache.has_key(id(pointer)):
+ raise RuntimeError, \
+ "What's this???"
+ pointer.set_type(cls)
+ _pointer_type_cache[cls] = pointer
+ del _pointer_type_cache[id(pointer)]
+
+
+def pointer(inst):
+ return POINTER(type(inst))(inst)
+
+# XXX Deprecated
+def ARRAY(typ, len):
+ return typ * len
+
+################################################################
+
+
+class CDLL(object):
+ """An instance of this class represents a loaded dll/shared
+ library, exporting functions using the standard C calling
+ convention (named 'cdecl' on Windows).
+
+ The exported functions can be accessed as attributes, or by
+ indexing with the function name. Examples:
+
+ <obj>.qsort -> callable object
+ <obj>['qsort'] -> callable object
+
+ Calling the functions releases the Python GIL during the call and
+ reaquires it afterwards.
+ """
+ class _FuncPtr(_CFuncPtr):
+ _flags_ = _FUNCFLAG_CDECL
+ _restype_ = c_int # default, can be overridden in instances
+
+ def __init__(self, name, mode=DEFAULT_MODE, handle=None):
+ self._name = name
+ if handle is None:
+ self._handle = _dlopen(self._name, mode)
+ else:
+ self._handle = handle
+
+ def __repr__(self):
+ return "<%s '%s', handle %x at %x>" % \
+ (self.__class__.__name__, self._name,
+ (self._handle & (_sys.maxint*2 + 1)),
+ id(self) & (_sys.maxint*2 + 1))
+
+ def __getattr__(self, name):
+ if name.startswith('__') and name.endswith('__'):
+ raise AttributeError, name
+ func = self.__getitem__(name)
+ setattr(self, name, func)
+ return func
+
+ def __getitem__(self, name_or_ordinal):
+ func = self._FuncPtr((name_or_ordinal, self))
+ if not isinstance(name_or_ordinal, (int, long)):
+ func.__name__ = name_or_ordinal
+ return func
+
+class PyDLL(CDLL):
+ """This class represents the Python library itself. It allows to
+ access Python API functions. The GIL is not released, and
+ Python exceptions are handled correctly.
+ """
+ class _FuncPtr(_CFuncPtr):
+ _flags_ = _FUNCFLAG_CDECL | _FUNCFLAG_PYTHONAPI
+ _restype_ = c_int # default, can be overridden in instances
+
+if _os.name in ("nt", "ce"):
+
+ class WinDLL(CDLL):
+ """This class represents a dll exporting functions using the
+ Windows stdcall calling convention.
+ """
+ class _FuncPtr(_CFuncPtr):
+ _flags_ = _FUNCFLAG_STDCALL
+ _restype_ = c_int # default, can be overridden in instances
+
+ # XXX Hm, what about HRESULT as normal parameter?
+ # Mustn't it derive from c_long then?
+ from _ctypes import _check_HRESULT, _SimpleCData
+ class HRESULT(_SimpleCData):
+ _type_ = "l"
+ # _check_retval_ is called with the function's result when it
+ # is used as restype. It checks for the FAILED bit, and
+ # raises a WindowsError if it is set.
+ #
+ # The _check_retval_ method is implemented in C, so that the
+ # method definition itself is not included in the traceback
+ # when it raises an error - that is what we want (and Python
+ # doesn't have a way to raise an exception in the caller's
+ # frame).
+ _check_retval_ = _check_HRESULT
+
+ class OleDLL(CDLL):
+ """This class represents a dll exporting functions using the
+ Windows stdcall calling convention, and returning HRESULT.
+ HRESULT error values are automatically raised as WindowsError
+ exceptions.
+ """
+ class _FuncPtr(_CFuncPtr):
+ _flags_ = _FUNCFLAG_STDCALL
+ _restype_ = HRESULT
+
+class LibraryLoader(object):
+ def __init__(self, dlltype):
+ self._dlltype = dlltype
+
+ def __getattr__(self, name):
+ if name[0] == '_':
+ raise AttributeError(name)
+ dll = self._dlltype(name)
+ setattr(self, name, dll)
+ return dll
+
+ def __getitem__(self, name):
+ return getattr(self, name)
+
+ def LoadLibrary(self, name):
+ return self._dlltype(name)
+
+cdll = LibraryLoader(CDLL)
+pydll = LibraryLoader(PyDLL)
+
+if _os.name in ("nt", "ce"):
+ pythonapi = PyDLL("python dll", None, _sys.dllhandle)
+elif _sys.platform == "cygwin":
+ pythonapi = PyDLL("libpython%d.%d.dll" % _sys.version_info[:2])
+else:
+ pythonapi = PyDLL(None)
+
+
+if _os.name in ("nt", "ce"):
+ windll = LibraryLoader(WinDLL)
+ oledll = LibraryLoader(OleDLL)
+
+ if _os.name == "nt":
+ GetLastError = windll.kernel32.GetLastError
+ else:
+ GetLastError = windll.coredll.GetLastError
+
+ def WinError(code=None, descr=None):
+ if code is None:
+ code = GetLastError()
+ if descr is None:
+ descr = FormatError(code).strip()
+ return WindowsError(code, descr)
+
+_pointer_type_cache[None] = c_void_p
+
+if sizeof(c_uint) == sizeof(c_void_p):
+ c_size_t = c_uint
+elif sizeof(c_ulong) == sizeof(c_void_p):
+ c_size_t = c_ulong
+
+# functions
+
+from _ctypes import _memmove_addr, _memset_addr, _string_at_addr, _cast_addr
+
+## void *memmove(void *, const void *, size_t);
+memmove = CFUNCTYPE(c_void_p, c_void_p, c_void_p, c_size_t)(_memmove_addr)
+
+## void *memset(void *, int, size_t)
+memset = CFUNCTYPE(c_void_p, c_void_p, c_int, c_size_t)(_memset_addr)
+
+def PYFUNCTYPE(restype, *argtypes):
+ class CFunctionType(_CFuncPtr):
+ _argtypes_ = argtypes
+ _restype_ = restype
+ _flags_ = _FUNCFLAG_CDECL | _FUNCFLAG_PYTHONAPI
+ return CFunctionType
+
+_cast = PYFUNCTYPE(py_object, c_void_p, py_object, py_object)(_cast_addr)
+def cast(obj, typ):
+ return _cast(obj, obj, typ)
+
+_string_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_string_at_addr)
+def string_at(ptr, size=-1):
+ """string_at(addr[, size]) -> string
+
+ Return the string at addr."""
+ return _string_at(ptr, size)
+
+try:
+ from _ctypes import _wstring_at_addr
+except ImportError:
+ pass
+else:
+ _wstring_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_wstring_at_addr)
+ def wstring_at(ptr, size=-1):
+ """wstring_at(addr[, size]) -> string
+
+ Return the string at addr."""
+ return _wstring_at(ptr, size)
+
+
+if _os.name in ("nt", "ce"): # COM stuff
+ def DllGetClassObject(rclsid, riid, ppv):
+ try:
+ ccom = __import__("comtypes.server.inprocserver", globals(), locals(), ['*'])
+ except ImportError:
+ return -2147221231 # CLASS_E_CLASSNOTAVAILABLE
+ else:
+ return ccom.DllGetClassObject(rclsid, riid, ppv)
+
+ def DllCanUnloadNow():
+ try:
+ ccom = __import__("comtypes.server.inprocserver", globals(), locals(), ['*'])
+ except ImportError:
+ return 0 # S_OK
+ return ccom.DllCanUnloadNow()
+
+from ctypes._endian import BigEndianStructure, LittleEndianStructure
+
+# Fill in specifically-sized types
+c_int8 = c_byte
+c_uint8 = c_ubyte
+for kind in [c_short, c_int, c_long, c_longlong]:
+ if sizeof(kind) == 2: c_int16 = kind
+ elif sizeof(kind) == 4: c_int32 = kind
+ elif sizeof(kind) == 8: c_int64 = kind
+for kind in [c_ushort, c_uint, c_ulong, c_ulonglong]:
+ if sizeof(kind) == 2: c_uint16 = kind
+ elif sizeof(kind) == 4: c_uint32 = kind
+ elif sizeof(kind) == 8: c_uint64 = kind
+del(kind)
Property changes on: branches/ctypes-via-rawffi/Lib/ctypes/__init__.py
___________________________________________________________________
Added: svn:eol-style
+ native
Added: branches/ctypes-via-rawffi/Lib/ctypes/_endian.py
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/_endian.py (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/_endian.py 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,60 @@
+######################################################################
+# This file should be kept compatible with Python 2.3, see PEP 291. #
+######################################################################
+import sys
+from ctypes import *
+
+_array_type = type(c_int * 3)
+
+def _other_endian(typ):
+ """Return the type with the 'other' byte order. Simple types like
+ c_int and so on already have __ctype_be__ and __ctype_le__
+ attributes which contain the types, for more complicated types
+ only arrays are supported.
+ """
+ try:
+ return getattr(typ, _OTHER_ENDIAN)
+ except AttributeError:
+ if type(typ) == _array_type:
+ return _other_endian(typ._type_) * typ._length_
+ raise TypeError("This type does not support other endian: %s" % typ)
+
+class _swapped_meta(type(Structure)):
+ def __setattr__(self, attrname, value):
+ if attrname == "_fields_":
+ fields = []
+ for desc in value:
+ name = desc[0]
+ typ = desc[1]
+ rest = desc[2:]
+ fields.append((name, _other_endian(typ)) + rest)
+ value = fields
+ super(_swapped_meta, self).__setattr__(attrname, value)
+
+################################################################
+
+# Note: The Structure metaclass checks for the *presence* (not the
+# value!) of a _swapped_bytes_ attribute to determine the bit order in
+# structures containing bit fields.
+
+if sys.byteorder == "little":
+ _OTHER_ENDIAN = "__ctype_be__"
+
+ LittleEndianStructure = Structure
+
+ class BigEndianStructure(Structure):
+ """Structure with big endian byte order"""
+ __metaclass__ = _swapped_meta
+ _swappedbytes_ = None
+
+elif sys.byteorder == "big":
+ _OTHER_ENDIAN = "__ctype_le__"
+
+ BigEndianStructure = Structure
+ class LittleEndianStructure(Structure):
+ """Structure with little endian byte order"""
+ __metaclass__ = _swapped_meta
+ _swappedbytes_ = None
+
+else:
+ raise RuntimeError("Invalid byteorder")
Property changes on: branches/ctypes-via-rawffi/Lib/ctypes/_endian.py
___________________________________________________________________
Added: svn:eol-style
+ native
Added: branches/ctypes-via-rawffi/Lib/ctypes/macholib/README.ctypes
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/macholib/README.ctypes (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/macholib/README.ctypes 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,7 @@
+Files in this directory from from Bob Ippolito's py2app.
+
+License: Any components of the py2app suite may be distributed under
+the MIT or PSF open source licenses.
+
+This is version 1.0, SVN revision 789, from 2006/01/25.
+The main repository is http://svn.red-bean.com/bob/macholib/trunk/macholib/
\ No newline at end of file
Added: branches/ctypes-via-rawffi/Lib/ctypes/macholib/__init__.py
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/macholib/__init__.py (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/macholib/__init__.py 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,12 @@
+######################################################################
+# This file should be kept compatible with Python 2.3, see PEP 291. #
+######################################################################
+"""
+Enough Mach-O to make your head spin.
+
+See the relevant header files in /usr/include/mach-o
+
+And also Apple's documentation.
+"""
+
+__version__ = '1.0'
Property changes on: branches/ctypes-via-rawffi/Lib/ctypes/macholib/__init__.py
___________________________________________________________________
Added: svn:eol-style
+ native
Added: branches/ctypes-via-rawffi/Lib/ctypes/macholib/dyld.py
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/macholib/dyld.py (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/macholib/dyld.py 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,169 @@
+######################################################################
+# This file should be kept compatible with Python 2.3, see PEP 291. #
+######################################################################
+"""
+dyld emulation
+"""
+
+import os
+from framework import framework_info
+from dylib import dylib_info
+from itertools import *
+
+__all__ = [
+ 'dyld_find', 'framework_find',
+ 'framework_info', 'dylib_info',
+]
+
+# These are the defaults as per man dyld(1)
+#
+DEFAULT_FRAMEWORK_FALLBACK = [
+ os.path.expanduser("~/Library/Frameworks"),
+ "/Library/Frameworks",
+ "/Network/Library/Frameworks",
+ "/System/Library/Frameworks",
+]
+
+DEFAULT_LIBRARY_FALLBACK = [
+ os.path.expanduser("~/lib"),
+ "/usr/local/lib",
+ "/lib",
+ "/usr/lib",
+]
+
+def ensure_utf8(s):
+ """Not all of PyObjC and Python understand unicode paths very well yet"""
+ if isinstance(s, unicode):
+ return s.encode('utf8')
+ return s
+
+def dyld_env(env, var):
+ if env is None:
+ env = os.environ
+ rval = env.get(var)
+ if rval is None:
+ return []
+ return rval.split(':')
+
+def dyld_image_suffix(env=None):
+ if env is None:
+ env = os.environ
+ return env.get('DYLD_IMAGE_SUFFIX')
+
+def dyld_framework_path(env=None):
+ return dyld_env(env, 'DYLD_FRAMEWORK_PATH')
+
+def dyld_library_path(env=None):
+ return dyld_env(env, 'DYLD_LIBRARY_PATH')
+
+def dyld_fallback_framework_path(env=None):
+ return dyld_env(env, 'DYLD_FALLBACK_FRAMEWORK_PATH')
+
+def dyld_fallback_library_path(env=None):
+ return dyld_env(env, 'DYLD_FALLBACK_LIBRARY_PATH')
+
+def dyld_image_suffix_search(iterator, env=None):
+ """For a potential path iterator, add DYLD_IMAGE_SUFFIX semantics"""
+ suffix = dyld_image_suffix(env)
+ if suffix is None:
+ return iterator
+ def _inject(iterator=iterator, suffix=suffix):
+ for path in iterator:
+ if path.endswith('.dylib'):
+ yield path[:-len('.dylib')] + suffix + '.dylib'
+ else:
+ yield path + suffix
+ yield path
+ return _inject()
+
+def dyld_override_search(name, env=None):
+ # If DYLD_FRAMEWORK_PATH is set and this dylib_name is a
+ # framework name, use the first file that exists in the framework
+ # path if any. If there is none go on to search the DYLD_LIBRARY_PATH
+ # if any.
+
+ framework = framework_info(name)
+
+ if framework is not None:
+ for path in dyld_framework_path(env):
+ yield os.path.join(path, framework['name'])
+
+ # If DYLD_LIBRARY_PATH is set then use the first file that exists
+ # in the path. If none use the original name.
+ for path in dyld_library_path(env):
+ yield os.path.join(path, os.path.basename(name))
+
+def dyld_executable_path_search(name, executable_path=None):
+ # If we haven't done any searching and found a library and the
+ # dylib_name starts with "@executable_path/" then construct the
+ # library name.
+ if name.startswith('@executable_path/') and executable_path is not None:
+ yield os.path.join(executable_path, name[len('@executable_path/'):])
+
+def dyld_default_search(name, env=None):
+ yield name
+
+ framework = framework_info(name)
+
+ if framework is not None:
+ fallback_framework_path = dyld_fallback_framework_path(env)
+ for path in fallback_framework_path:
+ yield os.path.join(path, framework['name'])
+
+ fallback_library_path = dyld_fallback_library_path(env)
+ for path in fallback_library_path:
+ yield os.path.join(path, os.path.basename(name))
+
+ if framework is not None and not fallback_framework_path:
+ for path in DEFAULT_FRAMEWORK_FALLBACK:
+ yield os.path.join(path, framework['name'])
+
+ if not fallback_library_path:
+ for path in DEFAULT_LIBRARY_FALLBACK:
+ yield os.path.join(path, os.path.basename(name))
+
+def dyld_find(name, executable_path=None, env=None):
+ """
+ Find a library or framework using dyld semantics
+ """
+ name = ensure_utf8(name)
+ executable_path = ensure_utf8(executable_path)
+ for path in dyld_image_suffix_search(chain(
+ dyld_override_search(name, env),
+ dyld_executable_path_search(name, executable_path),
+ dyld_default_search(name, env),
+ ), env):
+ if os.path.isfile(path):
+ return path
+ raise ValueError, "dylib %s could not be found" % (name,)
+
+def framework_find(fn, executable_path=None, env=None):
+ """
+ Find a framework using dyld semantics in a very loose manner.
+
+ Will take input such as:
+ Python
+ Python.framework
+ Python.framework/Versions/Current
+ """
+ try:
+ return dyld_find(fn, executable_path=executable_path, env=env)
+ except ValueError, e:
+ pass
+ fmwk_index = fn.rfind('.framework')
+ if fmwk_index == -1:
+ fmwk_index = len(fn)
+ fn += '.framework'
+ fn = os.path.join(fn, os.path.basename(fn[:fmwk_index]))
+ try:
+ return dyld_find(fn, executable_path=executable_path, env=env)
+ except ValueError:
+ raise e
+
+def test_dyld_find():
+ env = {}
+ assert dyld_find('libSystem.dylib') == '/usr/lib/libSystem.dylib'
+ assert dyld_find('System.framework/System') == '/System/Library/Frameworks/System.framework/System'
+
+if __name__ == '__main__':
+ test_dyld_find()
Property changes on: branches/ctypes-via-rawffi/Lib/ctypes/macholib/dyld.py
___________________________________________________________________
Added: svn:eol-style
+ native
Added: branches/ctypes-via-rawffi/Lib/ctypes/macholib/dylib.py
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/macholib/dylib.py (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/macholib/dylib.py 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,66 @@
+######################################################################
+# This file should be kept compatible with Python 2.3, see PEP 291. #
+######################################################################
+"""
+Generic dylib path manipulation
+"""
+
+import re
+
+__all__ = ['dylib_info']
+
+DYLIB_RE = re.compile(r"""(?x)
+(?P<location>^.*)(?:^|/)
+(?P<name>
+ (?P<shortname>\w+?)
+ (?:\.(?P<version>[^._]+))?
+ (?:_(?P<suffix>[^._]+))?
+ \.dylib$
+)
+""")
+
+def dylib_info(filename):
+ """
+ A dylib name can take one of the following four forms:
+ Location/Name.SomeVersion_Suffix.dylib
+ Location/Name.SomeVersion.dylib
+ Location/Name_Suffix.dylib
+ Location/Name.dylib
+
+ returns None if not found or a mapping equivalent to:
+ dict(
+ location='Location',
+ name='Name.SomeVersion_Suffix.dylib',
+ shortname='Name',
+ version='SomeVersion',
+ suffix='Suffix',
+ )
+
+ Note that SomeVersion and Suffix are optional and may be None
+ if not present.
+ """
+ is_dylib = DYLIB_RE.match(filename)
+ if not is_dylib:
+ return None
+ return is_dylib.groupdict()
+
+
+def test_dylib_info():
+ def d(location=None, name=None, shortname=None, version=None, suffix=None):
+ return dict(
+ location=location,
+ name=name,
+ shortname=shortname,
+ version=version,
+ suffix=suffix
+ )
+ assert dylib_info('completely/invalid') is None
+ assert dylib_info('completely/invalide_debug') is None
+ assert dylib_info('P/Foo.dylib') == d('P', 'Foo.dylib', 'Foo')
+ assert dylib_info('P/Foo_debug.dylib') == d('P', 'Foo_debug.dylib', 'Foo', suffix='debug')
+ assert dylib_info('P/Foo.A.dylib') == d('P', 'Foo.A.dylib', 'Foo', 'A')
+ assert dylib_info('P/Foo_debug.A.dylib') == d('P', 'Foo_debug.A.dylib', 'Foo_debug', 'A')
+ assert dylib_info('P/Foo.A_debug.dylib') == d('P', 'Foo.A_debug.dylib', 'Foo', 'A', 'debug')
+
+if __name__ == '__main__':
+ test_dylib_info()
Property changes on: branches/ctypes-via-rawffi/Lib/ctypes/macholib/dylib.py
___________________________________________________________________
Added: svn:eol-style
+ native
Added: branches/ctypes-via-rawffi/Lib/ctypes/macholib/fetch_macholib
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/macholib/fetch_macholib (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/macholib/fetch_macholib 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,2 @@
+#!/bin/sh
+svn export --force http://svn.red-bean.com/bob/macholib/trunk/macholib/ .
Property changes on: branches/ctypes-via-rawffi/Lib/ctypes/macholib/fetch_macholib
___________________________________________________________________
Added: svn:executable
+ *
Added: branches/ctypes-via-rawffi/Lib/ctypes/macholib/framework.py
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/macholib/framework.py (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/macholib/framework.py 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,68 @@
+######################################################################
+# This file should be kept compatible with Python 2.3, see PEP 291. #
+######################################################################
+"""
+Generic framework path manipulation
+"""
+
+import re
+
+__all__ = ['framework_info']
+
+STRICT_FRAMEWORK_RE = re.compile(r"""(?x)
+(?P<location>^.*)(?:^|/)
+(?P<name>
+ (?P<shortname>\w+).framework/
+ (?:Versions/(?P<version>[^/]+)/)?
+ (?P=shortname)
+ (?:_(?P<suffix>[^_]+))?
+)$
+""")
+
+def framework_info(filename):
+ """
+ A framework name can take one of the following four forms:
+ Location/Name.framework/Versions/SomeVersion/Name_Suffix
+ Location/Name.framework/Versions/SomeVersion/Name
+ Location/Name.framework/Name_Suffix
+ Location/Name.framework/Name
+
+ returns None if not found, or a mapping equivalent to:
+ dict(
+ location='Location',
+ name='Name.framework/Versions/SomeVersion/Name_Suffix',
+ shortname='Name',
+ version='SomeVersion',
+ suffix='Suffix',
+ )
+
+ Note that SomeVersion and Suffix are optional and may be None
+ if not present
+ """
+ is_framework = STRICT_FRAMEWORK_RE.match(filename)
+ if not is_framework:
+ return None
+ return is_framework.groupdict()
+
+def test_framework_info():
+ def d(location=None, name=None, shortname=None, version=None, suffix=None):
+ return dict(
+ location=location,
+ name=name,
+ shortname=shortname,
+ version=version,
+ suffix=suffix
+ )
+ assert framework_info('completely/invalid') is None
+ assert framework_info('completely/invalid/_debug') is None
+ assert framework_info('P/F.framework') is None
+ assert framework_info('P/F.framework/_debug') is None
+ assert framework_info('P/F.framework/F') == d('P', 'F.framework/F', 'F')
+ assert framework_info('P/F.framework/F_debug') == d('P', 'F.framework/F_debug', 'F', suffix='debug')
+ assert framework_info('P/F.framework/Versions') is None
+ assert framework_info('P/F.framework/Versions/A') is None
+ assert framework_info('P/F.framework/Versions/A/F') == d('P', 'F.framework/Versions/A/F', 'F', 'A')
+ assert framework_info('P/F.framework/Versions/A/F_debug') == d('P', 'F.framework/Versions/A/F_debug', 'F', 'A', 'debug')
+
+if __name__ == '__main__':
+ test_framework_info()
Property changes on: branches/ctypes-via-rawffi/Lib/ctypes/macholib/framework.py
___________________________________________________________________
Added: svn:eol-style
+ native
Added: branches/ctypes-via-rawffi/Lib/ctypes/test/__init__.py
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/test/__init__.py (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/test/__init__.py 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,202 @@
+import glob, os, sys, unittest, getopt, time
+
+use_resources = []
+
+class ResourceDenied(Exception):
+ """Test skipped because it requested a disallowed resource.
+
+ This is raised when a test calls requires() for a resource that
+ has not be enabled. Resources are defined by test modules.
+ """
+
+def is_resource_enabled(resource):
+ """Test whether a resource is enabled.
+
+ If the caller's module is __main__ then automatically return True."""
+ if sys._getframe().f_back.f_globals.get("__name__") == "__main__":
+ return True
+ result = use_resources is not None and \
+ (resource in use_resources or "*" in use_resources)
+ if not result:
+ _unavail[resource] = None
+ return result
+
+_unavail = {}
+def requires(resource, msg=None):
+ """Raise ResourceDenied if the specified resource is not available.
+
+ If the caller's module is __main__ then automatically return True."""
+ # see if the caller's module is __main__ - if so, treat as if
+ # the resource was set
+ if sys._getframe().f_back.f_globals.get("__name__") == "__main__":
+ return
+ if not is_resource_enabled(resource):
+ if msg is None:
+ msg = "Use of the `%s' resource not enabled" % resource
+ raise ResourceDenied(msg)
+
+def find_package_modules(package, mask):
+ import fnmatch
+ if hasattr(package, "__loader__"):
+ path = package.__name__.replace(".", os.path.sep)
+ mask = os.path.join(path, mask)
+ for fnm in package.__loader__._files.iterkeys():
+ if fnmatch.fnmatchcase(fnm, mask):
+ yield os.path.splitext(fnm)[0].replace(os.path.sep, ".")
+ else:
+ path = package.__path__[0]
+ for fnm in os.listdir(path):
+ if fnmatch.fnmatchcase(fnm, mask):
+ yield "%s.%s" % (package.__name__, os.path.splitext(fnm)[0])
+
+def get_tests(package, mask, verbosity):
+ """Return a list of skipped test modules, and a list of test cases."""
+ tests = []
+ skipped = []
+ for modname in find_package_modules(package, mask):
+ try:
+ mod = __import__(modname, globals(), locals(), ['*'])
+ except ResourceDenied, detail:
+ skipped.append(modname)
+ if verbosity > 1:
+ print >> sys.stderr, "Skipped %s: %s" % (modname, detail)
+ continue
+ except Exception, detail:
+ print >> sys.stderr, "Warning: could not import %s: %s" % (modname, detail)
+ continue
+ for name in dir(mod):
+ if name.startswith("_"):
+ continue
+ o = getattr(mod, name)
+ if type(o) is type(unittest.TestCase) and issubclass(o, unittest.TestCase):
+ tests.append(o)
+ return skipped, tests
+
+def usage():
+ print __doc__
+ return 1
+
+def test_with_refcounts(runner, verbosity, testcase):
+ """Run testcase several times, tracking reference counts."""
+ import gc
+ import ctypes
+ ptc = ctypes._pointer_type_cache.copy()
+ cfc = ctypes._c_functype_cache.copy()
+ wfc = ctypes._win_functype_cache.copy()
+
+ # when searching for refcount leaks, we have to manually reset any
+ # caches that ctypes has.
+ def cleanup():
+ ctypes._pointer_type_cache = ptc.copy()
+ ctypes._c_functype_cache = cfc.copy()
+ ctypes._win_functype_cache = wfc.copy()
+ gc.collect()
+
+ test = unittest.makeSuite(testcase)
+ for i in range(5):
+ rc = sys.gettotalrefcount()
+ runner.run(test)
+ cleanup()
+ COUNT = 5
+ refcounts = [None] * COUNT
+ for i in range(COUNT):
+ rc = sys.gettotalrefcount()
+ runner.run(test)
+ cleanup()
+ refcounts[i] = sys.gettotalrefcount() - rc
+ if filter(None, refcounts):
+ print "%s leaks:\n\t" % testcase, refcounts
+ elif verbosity:
+ print "%s: ok." % testcase
+
+class TestRunner(unittest.TextTestRunner):
+ def run(self, test, skipped):
+ "Run the given test case or test suite."
+ # Same as unittest.TextTestRunner.run, except that it reports
+ # skipped tests.
+ result = self._makeResult()
+ startTime = time.time()
+ test(result)
+ stopTime = time.time()
+ timeTaken = stopTime - startTime
+ result.printErrors()
+ self.stream.writeln(result.separator2)
+ run = result.testsRun
+ if _unavail: #skipped:
+ requested = _unavail.keys()
+ requested.sort()
+ self.stream.writeln("Ran %d test%s in %.3fs (%s module%s skipped)" %
+ (run, run != 1 and "s" or "", timeTaken,
+ len(skipped),
+ len(skipped) != 1 and "s" or ""))
+ self.stream.writeln("Unavailable resources: %s" % ", ".join(requested))
+ else:
+ self.stream.writeln("Ran %d test%s in %.3fs" %
+ (run, run != 1 and "s" or "", timeTaken))
+ self.stream.writeln()
+ if not result.wasSuccessful():
+ self.stream.write("FAILED (")
+ failed, errored = map(len, (result.failures, result.errors))
+ if failed:
+ self.stream.write("failures=%d" % failed)
+ if errored:
+ if failed: self.stream.write(", ")
+ self.stream.write("errors=%d" % errored)
+ self.stream.writeln(")")
+ else:
+ self.stream.writeln("OK")
+ return result
+
+
+def main(*packages):
+ try:
+ opts, args = getopt.getopt(sys.argv[1:], "rqvu:")
+ except getopt.error:
+ return usage()
+
+ verbosity = 1
+ search_leaks = False
+ for flag, value in opts:
+ if flag == "-q":
+ verbosity -= 1
+ elif flag == "-v":
+ verbosity += 1
+ elif flag == "-r":
+ try:
+ sys.gettotalrefcount
+ except AttributeError:
+ print >> sys.stderr, "-r flag requires Python debug build"
+ return -1
+ search_leaks = True
+ elif flag == "-u":
+ use_resources.extend(value.split(","))
+
+ mask = "test_*.py"
+ if args:
+ mask = args[0]
+
+ for package in packages:
+ run_tests(package, mask, verbosity, search_leaks)
+
+
+def run_tests(package, mask, verbosity, search_leaks):
+ skipped, testcases = get_tests(package, mask, verbosity)
+ runner = TestRunner(verbosity=verbosity)
+
+ suites = [unittest.makeSuite(o) for o in testcases]
+ suite = unittest.TestSuite(suites)
+ result = runner.run(suite, skipped)
+
+ if search_leaks:
+ # hunt for refcount leaks
+ runner = BasicTestRunner()
+ for t in testcases:
+ test_with_refcounts(runner, verbosity, t)
+
+ return bool(result.errors)
+
+class BasicTestRunner:
+ def run(self, test):
+ result = unittest.TestResult()
+ test(result)
+ return result
Property changes on: branches/ctypes-via-rawffi/Lib/ctypes/test/__init__.py
___________________________________________________________________
Added: svn:eol-style
+ native
Added: branches/ctypes-via-rawffi/Lib/ctypes/test/runtests.py
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/test/runtests.py (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/test/runtests.py 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,17 @@
+"""Usage: runtests.py [-q] [-r] [-v] [-u resources] [mask]
+
+Run all tests found in this directory, and print a summary of the results.
+Command line flags:
+ -q quiet mode: don't prnt anything while the tests are running
+ -r run tests repeatedly, look for refcount leaks
+ -u<resources>
+ Add resources to the lits of allowed resources. '*' allows all
+ resources.
+ -v verbose mode: print the test currently executed
+ mask mask to select filenames containing testcases, wildcards allowed
+"""
+import sys
+import ctypes.test
+
+if __name__ == "__main__":
+ sys.exit(ctypes.test.main(ctypes.test))
Property changes on: branches/ctypes-via-rawffi/Lib/ctypes/test/runtests.py
___________________________________________________________________
Added: svn:eol-style
+ native
Added: branches/ctypes-via-rawffi/Lib/ctypes/test/test_anon.py
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/test/test_anon.py (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/test/test_anon.py 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,60 @@
+import unittest
+from ctypes import *
+
+class AnonTest(unittest.TestCase):
+
+ def test_anon(self):
+ class ANON(Union):
+ _fields_ = [("a", c_int),
+ ("b", c_int)]
+
+ class Y(Structure):
+ _fields_ = [("x", c_int),
+ ("_", ANON),
+ ("y", c_int)]
+ _anonymous_ = ["_"]
+
+ self.failUnlessEqual(Y.a.offset, sizeof(c_int))
+ self.failUnlessEqual(Y.b.offset, sizeof(c_int))
+
+ self.failUnlessEqual(ANON.a.offset, 0)
+ self.failUnlessEqual(ANON.b.offset, 0)
+
+ def test_anon_nonseq(self):
+ # TypeError: _anonymous_ must be a sequence
+ self.failUnlessRaises(TypeError,
+ lambda: type(Structure)("Name",
+ (Structure,),
+ {"_fields_": [], "_anonymous_": 42}))
+
+ def test_anon_nonmember(self):
+ # AttributeError: type object 'Name' has no attribute 'x'
+ self.failUnlessRaises(AttributeError,
+ lambda: type(Structure)("Name",
+ (Structure,),
+ {"_fields_": [],
+ "_anonymous_": ["x"]}))
+
+ def test_nested(self):
+ class ANON_S(Structure):
+ _fields_ = [("a", c_int)]
+
+ class ANON_U(Union):
+ _fields_ = [("_", ANON_S),
+ ("b", c_int)]
+ _anonymous_ = ["_"]
+
+ class Y(Structure):
+ _fields_ = [("x", c_int),
+ ("_", ANON_U),
+ ("y", c_int)]
+ _anonymous_ = ["_"]
+
+ self.failUnlessEqual(Y.x.offset, 0)
+ self.failUnlessEqual(Y.a.offset, sizeof(c_int))
+ self.failUnlessEqual(Y.b.offset, sizeof(c_int))
+ self.failUnlessEqual(Y._.offset, sizeof(c_int))
+ self.failUnlessEqual(Y.y.offset, sizeof(c_int) * 2)
+
+if __name__ == "__main__":
+ unittest.main()
Property changes on: branches/ctypes-via-rawffi/Lib/ctypes/test/test_anon.py
___________________________________________________________________
Added: svn:eol-style
+ native
Added: branches/ctypes-via-rawffi/Lib/ctypes/test/test_array_in_pointer.py
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/test/test_array_in_pointer.py (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/test/test_array_in_pointer.py 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,64 @@
+import unittest
+from ctypes import *
+from binascii import hexlify
+import re
+
+def dump(obj):
+ # helper function to dump memory contents in hex, with a hyphen
+ # between the bytes.
+ h = hexlify(buffer(obj))
+ return re.sub(r"(..)", r"\1-", h)[:-1]
+
+
+class Value(Structure):
+ _fields_ = [("val", c_byte)]
+
+class Container(Structure):
+ _fields_ = [("pvalues", POINTER(Value))]
+
+class Test(unittest.TestCase):
+ def test(self):
+ # create an array of 4 values
+ val_array = (Value * 4)()
+
+ # create a container, which holds a pointer to the pvalues array.
+ c = Container()
+ c.pvalues = val_array
+
+ # memory contains 4 NUL bytes now, that's correct
+ self.failUnlessEqual("00-00-00-00", dump(val_array))
+
+ # set the values of the array through the pointer:
+ for i in range(4):
+ c.pvalues[i].val = i + 1
+
+ values = [c.pvalues[i].val for i in range(4)]
+
+ # These are the expected results: here s the bug!
+ self.failUnlessEqual(
+ (values, dump(val_array)),
+ ([1, 2, 3, 4], "01-02-03-04")
+ )
+
+ def test_2(self):
+
+ val_array = (Value * 4)()
+
+ # memory contains 4 NUL bytes now, that's correct
+ self.failUnlessEqual("00-00-00-00", dump(val_array))
+
+ ptr = cast(val_array, POINTER(Value))
+ # set the values of the array through the pointer:
+ for i in range(4):
+ ptr[i].val = i + 1
+
+ values = [ptr[i].val for i in range(4)]
+
+ # These are the expected results: here s the bug!
+ self.failUnlessEqual(
+ (values, dump(val_array)),
+ ([1, 2, 3, 4], "01-02-03-04")
+ )
+
+if __name__ == "__main__":
+ unittest.main()
Property changes on: branches/ctypes-via-rawffi/Lib/ctypes/test/test_array_in_pointer.py
___________________________________________________________________
Added: svn:eol-style
+ native
Added: branches/ctypes-via-rawffi/Lib/ctypes/test/test_arrays.py
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/test/test_arrays.py (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/test/test_arrays.py 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,112 @@
+import unittest
+from ctypes import *
+
+formats = "bBhHiIlLqQfd"
+
+formats = c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint, \
+ c_long, c_ulonglong, c_float, c_double
+
+class ArrayTestCase(unittest.TestCase):
+ def test_simple(self):
+ # create classes holding simple numeric types, and check
+ # various properties.
+
+ init = range(15, 25)
+
+ for fmt in formats:
+ alen = len(init)
+ int_array = ARRAY(fmt, alen)
+
+ ia = int_array(*init)
+ # length of instance ok?
+ self.failUnlessEqual(len(ia), alen)
+
+ # slot values ok?
+ values = [ia[i] for i in range(len(init))]
+ self.failUnlessEqual(values, init)
+
+ # change the items
+ from operator import setitem
+ new_values = range(42, 42+alen)
+ [setitem(ia, n, new_values[n]) for n in range(alen)]
+ values = [ia[i] for i in range(len(init))]
+ self.failUnlessEqual(values, new_values)
+
+ # are the items initialized to 0?
+ ia = int_array()
+ values = [ia[i] for i in range(len(init))]
+ self.failUnlessEqual(values, [0] * len(init))
+
+ # Too many in itializers should be caught
+ self.assertRaises(IndexError, int_array, *range(alen*2))
+
+ CharArray = ARRAY(c_char, 3)
+
+ ca = CharArray("a", "b", "c")
+
+ # Should this work? It doesn't:
+ # CharArray("abc")
+ self.assertRaises(TypeError, CharArray, "abc")
+
+ self.failUnlessEqual(ca[0], "a")
+ self.failUnlessEqual(ca[1], "b")
+ self.failUnlessEqual(ca[2], "c")
+ self.failUnlessEqual(ca[-3], "a")
+ self.failUnlessEqual(ca[-2], "b")
+ self.failUnlessEqual(ca[-1], "c")
+
+ self.failUnlessEqual(len(ca), 3)
+
+ # slicing is now supported, but not extended slicing (3-argument)!
+ from operator import getslice, delitem
+ self.assertRaises(TypeError, getslice, ca, 0, 1, -1)
+
+ # cannot delete items
+ self.assertRaises(TypeError, delitem, ca, 0)
+
+ def test_numeric_arrays(self):
+
+ alen = 5
+
+ numarray = ARRAY(c_int, alen)
+
+ na = numarray()
+ values = [na[i] for i in range(alen)]
+ self.failUnlessEqual(values, [0] * alen)
+
+ na = numarray(*[c_int()] * alen)
+ values = [na[i] for i in range(alen)]
+ self.failUnlessEqual(values, [0]*alen)
+
+ na = numarray(1, 2, 3, 4, 5)
+ values = [i for i in na]
+ self.failUnlessEqual(values, [1, 2, 3, 4, 5])
+
+ na = numarray(*map(c_int, (1, 2, 3, 4, 5)))
+ values = [i for i in na]
+ self.failUnlessEqual(values, [1, 2, 3, 4, 5])
+
+ def test_classcache(self):
+ self.failUnless(not ARRAY(c_int, 3) is ARRAY(c_int, 4))
+ self.failUnless(ARRAY(c_int, 3) is ARRAY(c_int, 3))
+
+ def test_from_address(self):
+ # Failed with 0.9.8, reported by JUrner
+ p = create_string_buffer("foo")
+ sz = (c_char * 3).from_address(addressof(p))
+ self.failUnlessEqual(sz[:], "foo")
+ self.failUnlessEqual(sz.value, "foo")
+
+ try:
+ create_unicode_buffer
+ except NameError:
+ pass
+ else:
+ def test_from_addressW(self):
+ p = create_unicode_buffer("foo")
+ sz = (c_wchar * 3).from_address(addressof(p))
+ self.failUnlessEqual(sz[:], "foo")
+ self.failUnlessEqual(sz.value, "foo")
+
+if __name__ == '__main__':
+ unittest.main()
Property changes on: branches/ctypes-via-rawffi/Lib/ctypes/test/test_arrays.py
___________________________________________________________________
Added: svn:eol-style
+ native
Added: branches/ctypes-via-rawffi/Lib/ctypes/test/test_as_parameter.py
===================================================================
--- branches/ctypes-via-rawffi/Lib/ctypes/test/test_as_parameter.py (rev 0)
+++ branches/ctypes-via-rawffi/Lib/ctypes/test/test_as_parameter.py 2009-04-29 04:39:13 UTC (rev 6276)
@@ -0,0 +1,215 @@
+import unittest
+from ctypes import *
+import _ctypes_test
+
+dll = CDLL(_ctypes_test.__file__)
+
+try:
+ CALLBACK_FUNCTYPE = WINFUNCTYPE
+except NameError:
+ # fake to enable this test on Linux
+ CALLBACK_FUNCTYPE = CFUNCTYPE
+
+class POINT(Structure):
+ _fields_ = [("x", c_int), ("y", c_int)]
+
+class BasicWrapTestCase(unittest.TestCase):
+ def wrap(self, param):
+ return param
+
+ def test_wchar_parm(self):
+ try:
+ c_wchar
+ except NameError:
+ return
+ f = dll._testfunc_i_bhilfd
+ f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double]
+ result = f(self.wrap(1), self.wrap(u"x"), self.wrap(3), self.wrap(4), self.wrap(5.0), self.wrap(6.0))
+ self.failUnlessEqual(result, 139)
+ self.failUnless(type(result), int)
+
+ def test_pointers(self):
+ f = dll._testfunc_p_p
+ f.restype = POINTER(c_int)
+ f.argtypes = [POINTER(c_int)]
+
+ # This only works if the value c_int(42) passed to the
+ # function is still alive while the pointer (the result) is
+ # used.
+
+ v = c_int(42)
+
+ self.failUnlessEqual(pointer(v).contents.value, 42)
+ result = f(self.wrap(pointer(v)))
+ self.failUnlessEqual(type(result), POINTER(c_int))
+ self.failUnlessEqual(result.contents.value, 42)
+
+ # This on works...
+ result = f(self.wrap(pointer(v)))
+ self.failUnlessEqual(result.contents.value, v.value)
+
+ p = pointer(c_int(99))
+ result = f(self.wrap(p))
+ self.failUnlessEqual(result.contents.value, 99)
+
+ def test_shorts(self):
+ f = dll._testfunc_callback_i_if
+
+ args = []
+ expected = [262144, 131072, 65536, 32768, 16384, 8192, 4096, 2048,
+ 1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1]
+
+ def callback(v):
+ args.append(v)
+ return v
+
+ CallBack = CFUNCTYPE(c_int, c_int)
+
+ cb = CallBack(callback)
+ f(self.wrap(2**18), self.wrap(cb))
+ self.failUnlessEqual(args, expected)
+
+ ################################################################
+
+ def test_callbacks(self):
+ f = dll._testfunc_callback_i_if
+ f.restype = c_int
+
+ MyCallback = CFUNCTYPE(c_int, c_int)
+
+ def callback(value):
+ #print "called back with", value
+ return value
+
+ cb = MyCallback(callback)
+
+ result = f(self.wrap(-10), self.wrap(cb))
+ self.failUnlessEqual(result, -18)
+
+ # test with prototype
+ f.argtypes = [c_int, MyCallback]
+ cb = MyCallback(callback)
+
+ result = f(self.wrap(-10), self.wrap(cb))
+ self.failUnlessEqual(result, -18)
+
+ result = f(self.wrap(-10), self.wrap(cb))
+ self.failUnlessEqual(result, -18)
+
+ AnotherCallback = CALLBACK_FUNCTYPE(c_int, c_int, c_int, c_int, c_int)
+
+ # check that the prototype works: we call f with wrong
+ # argument types
+ cb = AnotherCallback(callback)
+ self.assertRaises(ArgumentError, f, self.wrap(-10), self.wrap(cb))
+
+ def test_callbacks_2(self):
+ # Can also use simple datatypes as argument type specifiers
+ # for the callback function.
+ # In this case the call receives an instance of that type
+ f = dll._testfunc_callback_i_if
+ f.restype = c_int
+
+ MyCallback = CFUNCTYPE(c_int, c_int)
+
+ f.argtypes = [c_int, MyCallback]
+
+ def callback(value):
+ #print "called back with", value
+ self.failUnlessEqual(type(value), int)
+ return value
+
+ cb = MyCallback(callback)
+ result = f(self.wrap(-10), self.wrap(cb))
+ self.failUnlessEqual(result, -18)
+
+ def test_longlong_callbacks(self):
+
+ f = dll._testfunc_callback_q_qf
+ f.restype = c_longlong
+
+ MyCallback = CFUNCTYPE(c_longlong, c_longlong)
...
[truncated message content] |
