# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# Maciej Olko <maciej.olko@gmail.com>, 2025

# python-doc bot, 2026

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-04-11 14:31+0000\n"

"PO-Revision-Date: 2025-09-16 00:01+0000\n"

"Last-Translator: python-doc bot, 2026\n"

"Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: pl\n"

"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "

"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "

"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"

msgid ":mod:`!ctypes` --- A foreign function library for Python"

msgstr ""

msgid "**Source code:** :source:`Lib/ctypes`"

msgstr "**Kod źródłowy:** :source:`Lib/ctypes`"

msgid ""

":mod:`!ctypes` is a foreign function library for Python. It provides C "

"compatible data types, and allows calling functions in DLLs or shared "

"libraries. It can be used to wrap these libraries in pure Python."

msgstr ""

msgid ""

"This is an :term:`optional module`. If it is missing from your copy of "

"CPython, look for documentation from your distributor (that is, whoever "

"provided Python to you). If you are the distributor, see :ref:`optional-"

"module-requirements`."

msgstr ""

"To jest :term:`moduł opcjonalny <optional module>`. Jeśli brakuje go w "

"twojej kopii CPythona, poszukaj dokumentacji od dystrybutora (czyli tego, "

"kto dostarczył ci Pythona). Jeśli jesteś dystrybutorem, zobacz :ref:"

"`optional-module-requirements`."

msgid "ctypes tutorial"

msgstr ""

msgid ""

"Note: Some code samples reference the ctypes :class:`c_int` type. On "

"platforms where ``sizeof(long) == sizeof(int)`` it is an alias to :class:"

"`c_long`. So, you should not be confused if :class:`c_long` is printed if "

"you would expect :class:`c_int` --- they are actually the same type."

msgstr ""

msgid "Loading dynamic link libraries"

msgstr ""

msgid ""

":mod:`!ctypes` exports the :py:data:`~ctypes.cdll`, and on Windows :py:data:"

"`~ctypes.windll` and :py:data:`~ctypes.oledll` objects, for loading dynamic "

"link libraries."

msgstr ""

msgid ""

"You load libraries by accessing them as attributes of these objects. :py:"

"data:`!cdll` loads libraries which export functions using the standard "

"``cdecl`` calling convention, while :py:data:`!windll` libraries call "

"functions using the ``stdcall`` calling convention. :py:data:`~oledll` also "

"uses the ``stdcall`` calling convention, and assumes the functions return a "

"Windows :c:type:`!HRESULT` error code. The error code is used to "

"automatically raise an :class:`OSError` exception when the function call "

"fails."

msgstr ""

msgid ""

"Windows errors used to raise :exc:`WindowsError`, which is now an alias of :"

"exc:`OSError`."

msgstr ""

msgid ""

"Here are some examples for Windows. Note that ``msvcrt`` is the MS standard "

"C library containing most standard C functions, and uses the ``cdecl`` "

"calling convention::"

msgstr ""

msgid ""

">>> from ctypes import *\n"

">>> print(windll.kernel32)\n"

"<WinDLL 'kernel32', handle ... at ...>\n"

">>> print(cdll.msvcrt)\n"

"<CDLL 'msvcrt', handle ... at ...>\n"

">>> libc = cdll.msvcrt\n"

">>>"

msgstr ""

msgid "Windows appends the usual ``.dll`` file suffix automatically."

msgstr ""

msgid ""

"Accessing the standard C library through ``cdll.msvcrt`` will use an "

"outdated version of the library that may be incompatible with the one being "

"used by Python. Where possible, use native Python functionality, or else "

"import and use the ``msvcrt`` module."

msgstr ""

msgid ""

"Other systems require the filename *including* the extension to load a "

"library, so attribute access can not be used to load libraries. Either the :"

"meth:`~LibraryLoader.LoadLibrary` method of the dll loaders should be used, "

"or you should load the library by creating an instance of :py:class:`CDLL` "

"by calling the constructor."

msgstr ""

msgid "For example, on Linux::"

msgstr ""

msgid ""

">>> cdll.LoadLibrary(\"libc.so.6\")\n"

"<CDLL 'libc.so.6', handle ... at ...>\n"

">>> libc = CDLL(\"libc.so.6\")\n"

">>> libc\n"

"<CDLL 'libc.so.6', handle ... at ...>\n"

">>>"

msgstr ""

msgid "On macOS::"

msgstr ""

msgid ""

">>> cdll.LoadLibrary(\"libc.dylib\")\n"

"<CDLL 'libc.dylib', handle ... at ...>\n"

">>> libc = CDLL(\"libc.dylib\")\n"

">>> libc\n"

"<CDLL 'libc.dylib', handle ... at ...>"

msgstr ""

msgid "Accessing functions from loaded dlls"

msgstr ""

msgid "Functions are accessed as attributes of dll objects::"

msgstr ""

msgid ""

">>> libc.printf\n"

"<_FuncPtr object at 0x...>\n"

">>> print(windll.kernel32.GetModuleHandleA)\n"

"<_FuncPtr object at 0x...>\n"

">>> print(windll.kernel32.MyOwnFunction)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" File \"ctypes.py\", line 239, in __getattr__\n"

" func = _StdcallFuncPtr(name, self)\n"

"AttributeError: function 'MyOwnFunction' not found\n"

">>>"

msgstr ""

msgid ""

"Note that win32 system dlls like ``kernel32`` and ``user32`` often export "

"ANSI as well as UNICODE versions of a function. The UNICODE version is "

"exported with a ``W`` appended to the name, while the ANSI version is "

"exported with an ``A`` appended to the name. The win32 ``GetModuleHandle`` "

"function, which returns a *module handle* for a given module name, has the "

"following C prototype, and a macro is used to expose one of them as "

"``GetModuleHandle`` depending on whether UNICODE is defined or not::"

msgstr ""

msgid ""

"/* ANSI version */\n"

"HMODULE GetModuleHandleA(LPCSTR lpModuleName);\n"

"/* UNICODE version */\n"

"HMODULE GetModuleHandleW(LPCWSTR lpModuleName);"

msgstr ""

msgid ""

"*windll* does not try to select one of them by magic, you must access the "

"version you need by specifying ``GetModuleHandleA`` or ``GetModuleHandleW`` "

"explicitly, and then call it with bytes or string objects respectively."

msgstr ""

msgid ""

"Sometimes, dlls export functions with names which aren't valid Python "

"identifiers, like ``\"??2@YAPAXI@Z\"``. In this case you have to use :func:"

"`getattr` to retrieve the function::"

msgstr ""

msgid ""

">>> getattr(cdll.msvcrt, \"??2@YAPAXI@Z\")\n"

"<_FuncPtr object at 0x...>\n"

">>>"

msgstr ""

msgid ""

"On Windows, some dlls export functions not by name but by ordinal. These "

"functions can be accessed by indexing the dll object with the ordinal "

"number::"

msgstr ""

msgid ""

">>> cdll.kernel32[1]\n"

"<_FuncPtr object at 0x...>\n"

">>> cdll.kernel32[0]\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" File \"ctypes.py\", line 310, in __getitem__\n"

" func = _StdcallFuncPtr(name, self)\n"

"AttributeError: function ordinal 0 not found\n"

">>>"

msgstr ""

msgid "Calling functions"

msgstr ""

msgid ""

"You can call these functions like any other Python callable. This example "

"uses the ``rand()`` function, which takes no arguments and returns a pseudo-"

"random integer::"

msgstr ""

msgid ""

">>> print(libc.rand())\n"

"1804289383"

msgstr ""

msgid ""

"On Windows, you can call the ``GetModuleHandleA()`` function, which returns "

"a win32 module handle (passing ``None`` as single argument to call it with a "

"``NULL`` pointer)::"

msgstr ""

msgid ""

">>> print(hex(windll.kernel32.GetModuleHandleA(None)))\n"

"0x1d000000\n"

">>>"

msgstr ""

msgid ""

":exc:`ValueError` is raised when you call an ``stdcall`` function with the "

"``cdecl`` calling convention, or vice versa::"

msgstr ""

msgid ""

">>> cdll.kernel32.GetModuleHandleA(None)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ValueError: Procedure probably called with not enough arguments (4 bytes "

"missing)\n"

">>>\n"

"\n"

">>> windll.msvcrt.printf(b\"spam\")\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ValueError: Procedure probably called with too many arguments (4 bytes in "

"excess)\n"

">>>"

msgstr ""

msgid ""

"To find out the correct calling convention you have to look into the C "

"header file or the documentation for the function you want to call."

msgstr ""

msgid ""

"On Windows, :mod:`!ctypes` uses win32 structured exception handling to "

"prevent crashes from general protection faults when functions are called "

"with invalid argument values::"

msgstr ""

msgid ""

">>> windll.kernel32.GetModuleHandleA(32)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"OSError: exception: access violation reading 0x00000020\n"

">>>"

msgstr ""

msgid ""

"There are, however, enough ways to crash Python with :mod:`!ctypes`, so you "

"should be careful anyway. The :mod:`faulthandler` module can be helpful in "

"debugging crashes (e.g. from segmentation faults produced by erroneous C "

"library calls)."

msgstr ""

msgid ""

"``None``, integers, bytes objects and (unicode) strings are the only native "

"Python objects that can directly be used as parameters in these function "

"calls. ``None`` is passed as a C ``NULL`` pointer, bytes objects and strings "

"are passed as pointer to the memory block that contains their data (:c:expr:"

"`char *` or :c:expr:`wchar_t *`). Python integers are passed as the "

"platform's default C :c:expr:`int` type, their value is masked to fit into "

"the C type."

msgstr ""

msgid ""

"Before we move on calling functions with other parameter types, we have to "

"learn more about :mod:`!ctypes` data types."

msgstr ""

msgid "Fundamental data types"

msgstr ""

msgid ":mod:`!ctypes` defines a number of primitive C compatible data types:"

msgstr ""

msgid "ctypes type"

msgstr ""

msgid "C type"

msgstr ""

msgid "Python type"

msgstr ""

msgid ":py:attr:`~_SimpleCData._type_`"

msgstr ""

msgid ":class:`c_bool`"

msgstr ":class:`c_bool`"

msgid ":c:expr:`_Bool`"

msgstr ":c:expr:`_Bool`"

msgid ":py:class:`bool`"

msgstr ":py:class:`bool`"

msgid "``'?'``"

msgstr ""

msgid ":class:`c_char`"

msgstr ":class:`c_char`"

msgid ":c:expr:`char`"

msgstr ":c:expr:`char`"

msgid "1-character :py:class:`bytes`"

msgstr ""

msgid "``'c'``"

msgstr "``'c'``"

msgid ":class:`c_wchar`"

msgstr ":class:`c_wchar`"

msgid ":c:type:`wchar_t`"

msgstr ":c:type:`wchar_t`"

msgid "1-character :py:class:`str`"

msgstr ""

msgid "``'u'``"

msgstr "``'u'``"

msgid ":class:`c_byte`"

msgstr ":class:`c_byte`"

msgid ":py:class:`int`"

msgstr ":py:class:`int`"

msgid "``'b'``"

msgstr "``'b'``"

msgid ":class:`c_ubyte`"

msgstr ":class:`c_ubyte`"

msgid ":c:expr:`unsigned char`"

msgstr ":c:expr:`unsigned char`"

msgid "``'B'``"

msgstr "``'B'``"

msgid ":class:`c_short`"

msgstr ":class:`c_short`"

msgid ":c:expr:`short`"

msgstr ":c:expr:`short`"

msgid "``'h'``"

msgstr "``'h'``"

msgid ":class:`c_ushort`"

msgstr ":class:`c_ushort`"

msgid ":c:expr:`unsigned short`"

msgstr ":c:expr:`unsigned short`"

msgid "``'H'``"

msgstr "``'H'``"

msgid ":class:`c_int`"

msgstr ":class:`c_int`"

msgid ":c:expr:`int`"

msgstr ":c:expr:`int`"

msgid "``'i'`` \\*"

msgstr ""

msgid ":class:`c_int8`"

msgstr ""

msgid ":c:type:`int8_t`"

msgstr ""

msgid "\\*"

msgstr ""

msgid ":class:`c_int16`"

msgstr ""

msgid ":c:type:`int16_t`"

msgstr ""

msgid ":class:`c_int32`"

msgstr ""

msgid ":c:type:`int32_t`"

msgstr ""

msgid ":class:`c_int64`"

msgstr ""

msgid ":c:type:`int64_t`"

msgstr ""

msgid ":class:`c_uint`"

msgstr ":class:`c_uint`"

msgid ":c:expr:`unsigned int`"

msgstr ":c:expr:`unsigned int`"

msgid "``'I'`` \\*"

msgstr ""

msgid ":class:`c_uint8`"

msgstr ""

msgid ":c:type:`uint8_t`"

msgstr ""

msgid ":class:`c_uint16`"

msgstr ""

msgid ":c:type:`uint16_t`"

msgstr ""

msgid ":class:`c_uint32`"

msgstr ""

msgid ":c:type:`uint32_t`"

msgstr ""

msgid ":class:`c_uint64`"

msgstr ""

msgid ":c:type:`uint64_t`"

msgstr ""

msgid ":class:`c_long`"

msgstr ":class:`c_long`"

msgid ":c:expr:`long`"

msgstr ":c:expr:`long`"

msgid "``'l'``"

msgstr "``'I'``"

msgid ":class:`c_ulong`"

msgstr ":class:`c_ulong`"

msgid ":c:expr:`unsigned long`"

msgstr ":c:expr:`unsigned long`"

msgid "``'L'``"

msgstr "``'L'``"

msgid ":class:`c_longlong`"

msgstr ":class:`c_longlong`"

msgid ":c:expr:`long long`"

msgstr ":c:expr:`long long`"

msgid "``'q'`` \\*"

msgstr ""

msgid ":class:`c_ulonglong`"

msgstr ":class:`c_ulonglong`"

msgid ":c:expr:`unsigned long long`"

msgstr ""

msgid "``'Q'`` \\*"

msgstr ""

msgid ":class:`c_size_t`"

msgstr ":class:`c_size_t`"

msgid ":c:type:`size_t`"

msgstr ":c:type:`size_t`"

msgid ":class:`c_ssize_t`"

msgstr ":class:`c_ssize_t`"

msgid ":c:type:`Py_ssize_t`"

msgstr ":c:type:`Py_ssize_t`"

msgid ":class:`c_time_t`"

msgstr ":class:`c_time_t`"

msgid ":c:type:`time_t`"

msgstr ":c:type:`time_t`"

msgid ":class:`c_float`"

msgstr ":class:`c_float`"

msgid ":c:expr:`float`"

msgstr ":c:expr:`float`"

msgid ":py:class:`float`"

msgstr ":py:class:`float`"

msgid "``'f'``"

msgstr "``'f'``"

msgid ":class:`c_double`"

msgstr ":class:`c_double`"

msgid ":c:expr:`double`"

msgstr ":c:expr:`double`"

msgid "``'d'``"

msgstr "``'d'``"

msgid ":class:`c_longdouble`"

msgstr ":class:`c_longdouble`"

msgid ":c:expr:`long double`"

msgstr ":c:expr:`long double`"

msgid "``'g'`` \\*"

msgstr ""

msgid ":class:`c_char_p`"

msgstr ":class:`c_char_p`"

msgid ":c:expr:`char *` (NUL terminated)"

msgstr ""

msgid ":py:class:`bytes` or ``None``"

msgstr ""

msgid "``'z'``"

msgstr ""

msgid ":class:`c_wchar_p`"

msgstr ":class:`c_wchar_p`"

msgid ":c:expr:`wchar_t *` (NUL terminated)"

msgstr ""

msgid ":py:class:`str` or ``None``"

msgstr ""

msgid "``'Z'``"

msgstr ""

msgid ":class:`c_void_p`"

msgstr ":class:`c_void_p`"

msgid ":c:expr:`void *`"

msgstr ":c:expr:`void *`"

msgid ":py:class:`int` or ``None``"

msgstr ""

msgid "``'P'``"

msgstr ""

msgid ":class:`py_object`"

msgstr ""

msgid ":c:expr:`PyObject *`"

msgstr ":c:expr:`PyObject *`"

msgid ":py:class:`object`"

msgstr ""

msgid "``'O'``"

msgstr ""

msgid ":ref:`VARIANT_BOOL <ctypes-wintypes>`"

msgstr ""

msgid ":c:expr:`short int`"

msgstr ""

msgid "``'v'``"

msgstr ""

msgid ""

"Additionally, if IEC 60559 compatible complex arithmetic (Annex G) is "

"supported in both C and ``libffi``, the following complex types are "

"available:"

msgstr ""

msgid ":class:`c_float_complex`"

msgstr ":class:`c_float_complex`"

msgid ":c:expr:`float complex`"

msgstr ":c:expr:`float complex`"

msgid ":py:class:`complex`"

msgstr ""

msgid "``'F'``"

msgstr "``'F'``"

msgid ":class:`c_double_complex`"

msgstr ":class:`c_double_complex`"

msgid ":c:expr:`double complex`"

msgstr ":c:expr:`double complex`"

msgid "``'D'``"

msgstr "``'D'``"

msgid ":class:`c_longdouble_complex`"

msgstr ":class:`c_longdouble_complex`"

msgid ":c:expr:`long double complex`"

msgstr ""

msgid "``'G'``"

msgstr "``'G'``"

msgid ""

"All these types can be created by calling them with an optional initializer "

"of the correct type and value::"

msgstr ""

msgid ""

">>> c_int()\n"

"c_long(0)\n"

">>> c_wchar_p(\"Hello, World\")\n"

"c_wchar_p(140018365411392)\n"

">>> c_ushort(-3)\n"

"c_ushort(65533)\n"

">>>"

msgstr ""

">>> c_int()\n"

"c_long(0)\n"

">>> c_wchar_p(\"Hello, World\")\n"

"c_wchar_p(140018365411392)\n"

">>> c_ushort(-3)\n"

"c_ushort(65533)\n"

">>>"

msgid ""

"The constructors for numeric types will convert input using :py:meth:"

"`~object.__bool__`, :py:meth:`~object.__index__` (for ``int``), :py:meth:"

"`~object.__float__` or :py:meth:`~object.__complex__`. This means :py:class:"

"`~ctypes.c_bool` accepts any object with a truth value::"

msgstr ""

msgid ""

">>> empty_list = []\n"

">>> c_bool(empty_list)\n"

"c_bool(False)"

msgstr ""

msgid ""

"Since these types are mutable, their value can also be changed afterwards::"

msgstr ""

msgid ""

">>> i = c_int(42)\n"

">>> print(i)\n"

"c_long(42)\n"

">>> print(i.value)\n"

"42\n"

">>> i.value = -99\n"

">>> print(i.value)\n"

"-99\n"

">>>"

msgstr ""

msgid ""

"Assigning a new value to instances of the pointer types :class:`c_char_p`, :"

"class:`c_wchar_p`, and :class:`c_void_p` changes the *memory location* they "

"point to, *not the contents* of the memory block (of course not, because "

"Python string objects are immutable)::"

msgstr ""

msgid ""

">>> s = \"Hello, World\"\n"

">>> c_s = c_wchar_p(s)\n"

">>> print(c_s)\n"

"c_wchar_p(139966785747344)\n"

">>> print(c_s.value)\n"

"Hello World\n"

">>> c_s.value = \"Hi, there\"\n"

">>> print(c_s) # the memory location has changed\n"

"c_wchar_p(139966783348904)\n"

">>> print(c_s.value)\n"

"Hi, there\n"

">>> print(s) # first object is unchanged\n"

"Hello, World\n"

">>>"

msgstr ""

msgid ""

"You should be careful, however, not to pass them to functions expecting "

"pointers to mutable memory. If you need mutable memory blocks, ctypes has a :"

"func:`create_string_buffer` function which creates these in various ways. "

"The current memory block contents can be accessed (or changed) with the "

"``raw`` property; if you want to access it as NUL terminated string, use the "

"``value`` property::"

msgstr ""

msgid ""

">>> from ctypes import *\n"

">>> p = create_string_buffer(3) # create a 3 byte buffer, "

"initialized to NUL bytes\n"

">>> print(sizeof(p), repr(p.raw))\n"

"3 b'\\x00\\x00\\x00'\n"

">>> p = create_string_buffer(b\"Hello\") # create a buffer containing a "

"NUL terminated string\n"

">>> print(sizeof(p), repr(p.raw))\n"

"6 b'Hello\\x00'\n"

">>> print(repr(p.value))\n"

"b'Hello'\n"

">>> p = create_string_buffer(b\"Hello\", 10) # create a 10 byte buffer\n"

">>> print(sizeof(p), repr(p.raw))\n"

"10 b'Hello\\x00\\x00\\x00\\x00\\x00'\n"

">>> p.value = b\"Hi\"\n"

">>> print(sizeof(p), repr(p.raw))\n"

"10 b'Hi\\x00lo\\x00\\x00\\x00\\x00\\x00'\n"

">>>"

msgstr ""

msgid ""

"The :func:`create_string_buffer` function replaces the old :func:`!c_buffer` "

"function (which is still available as an alias). To create a mutable memory "

"block containing unicode characters of the C type :c:type:`wchar_t`, use "

"the :func:`create_unicode_buffer` function."

msgstr ""

msgid "Calling functions, continued"

msgstr ""

msgid ""

"Note that printf prints to the real standard output channel, *not* to :data:"

"`sys.stdout`, so these examples will only work at the console prompt, not "

"from within *IDLE* or *PythonWin*::"

msgstr ""

msgid ""

">>> printf = libc.printf\n"

">>> printf(b\"Hello, %s\\n\", b\"World!\")\n"

"Hello, World!\n"

"14\n"

">>> printf(b\"Hello, %S\\n\", \"World!\")\n"

"Hello, World!\n"

"14\n"

">>> printf(b\"%d bottles of beer\\n\", 42)\n"

"42 bottles of beer\n"

"19\n"

">>> printf(b\"%f bottles of beer\\n\", 42.5)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ctypes.ArgumentError: argument 2: TypeError: Don't know how to convert "

"parameter 2\n"

">>>"

msgstr ""

msgid ""

"As has been mentioned before, all Python types except integers, strings, and "

"bytes objects have to be wrapped in their corresponding :mod:`!ctypes` type, "

"so that they can be converted to the required C data type::"

msgstr ""

msgid ""

">>> printf(b\"An int %d, a double %f\\n\", 1234, c_double(3.14))\n"

"An int 1234, a double 3.140000\n"

"31\n"

">>>"

msgstr ""

msgid "Calling variadic functions"

msgstr ""

msgid ""

"On a lot of platforms calling variadic functions through ctypes is exactly "

"the same as calling functions with a fixed number of parameters. On some "

"platforms, and in particular ARM64 for Apple Platforms, the calling "

"convention for variadic functions is different than that for regular "

"functions."

msgstr ""

msgid ""

"On those platforms it is required to specify the :attr:`~_CFuncPtr.argtypes` "

"attribute for the regular, non-variadic, function arguments:"

msgstr ""

msgid "libc.printf.argtypes = [ctypes.c_char_p]"

msgstr ""

msgid ""

"Because specifying the attribute does not inhibit portability it is advised "

"to always specify :attr:`~_CFuncPtr.argtypes` for all variadic functions."

msgstr ""

msgid "Calling functions with your own custom data types"

msgstr ""

msgid ""

"You can also customize :mod:`!ctypes` argument conversion to allow instances "

"of your own classes be used as function arguments. :mod:`!ctypes` looks for "

"an :attr:`!_as_parameter_` attribute and uses this as the function argument. "

"The attribute must be an integer, string, bytes, a :mod:`!ctypes` instance, "

"or an object with an :attr:`!_as_parameter_` attribute::"

msgstr ""

msgid ""

">>> class Bottles:\n"

"... def __init__(self, number):\n"

"... self._as_parameter_ = number\n"

"...\n"

">>> bottles = Bottles(42)\n"

">>> printf(b\"%d bottles of beer\\n\", bottles)\n"

"42 bottles of beer\n"

"19\n"

">>>"

msgstr ""

msgid ""

"If you don't want to store the instance's data in the :attr:`!"

"_as_parameter_` instance variable, you could define a :class:`property` "

"which makes the attribute available on request."

msgstr ""

msgid "Specifying the required argument types (function prototypes)"

msgstr ""

msgid ""

"It is possible to specify the required argument types of functions exported "

"from DLLs by setting the :attr:`~_CFuncPtr.argtypes` attribute."

msgstr ""

msgid ""

":attr:`~_CFuncPtr.argtypes` must be a sequence of C data types (the :func:`!"

"printf` function is probably not a good example here, because it takes a "

"variable number and different types of parameters depending on the format "

"string, on the other hand this is quite handy to experiment with this "

"feature)::"

msgstr ""

msgid ""

">>> printf.argtypes = [c_char_p, c_char_p, c_int, c_double]\n"

">>> printf(b\"String '%s', Int %d, Double %f\\n\", b\"Hi\", 10, 2.2)\n"

"String 'Hi', Int 10, Double 2.200000\n"

"37\n"

">>>"

msgstr ""

msgid ""

"Specifying a format protects against incompatible argument types (just as a "

"prototype for a C function), and tries to convert the arguments to valid "

"types::"

msgstr ""

msgid ""

">>> printf(b\"%d %d %d\", 1, 2, 3)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ctypes.ArgumentError: argument 2: TypeError: 'int' object cannot be "

"interpreted as ctypes.c_char_p\n"

">>> printf(b\"%s %d %f\\n\", b\"X\", 2, 3)\n"

"X 2 3.000000\n"

"13\n"

">>>"

msgstr ""

msgid ""

"If you have defined your own classes which you pass to function calls, you "

"have to implement a :meth:`~_CData.from_param` class method for them to be "

"able to use them in the :attr:`~_CFuncPtr.argtypes` sequence. The :meth:"

"`~_CData.from_param` class method receives the Python object passed to the "

"function call, it should do a typecheck or whatever is needed to make sure "

"this object is acceptable, and then return the object itself, its :attr:`!"

"_as_parameter_` attribute, or whatever you want to pass as the C function "

"argument in this case. Again, the result should be an integer, string, "

"bytes, a :mod:`!ctypes` instance, or an object with an :attr:`!"

"_as_parameter_` attribute."

msgstr ""

msgid "Return types"

msgstr ""

msgid ""

"By default functions are assumed to return the C :c:expr:`int` type. Other "

"return types can be specified by setting the :attr:`~_CFuncPtr.restype` "

"attribute of the function object."

msgstr ""

msgid ""

"The C prototype of :c:func:`time` is ``time_t time(time_t *)``. Because :c:"

"type:`time_t` might be of a different type than the default return type :c:"

"expr:`int`, you should specify the :attr:`!restype` attribute::"

msgstr ""

msgid ">>> libc.time.restype = c_time_t"

msgstr ">>> libc.time.restype = c_time_t"

msgid "The argument types can be specified using :attr:`~_CFuncPtr.argtypes`::"

msgstr ""

msgid ">>> libc.time.argtypes = (POINTER(c_time_t),)"

msgstr ">>> libc.time.argtypes = (POINTER(c_time_t),)"

msgid ""

"To call the function with a ``NULL`` pointer as first argument, use "

"``None``::"

msgstr ""

msgid ""

">>> print(libc.time(None))\n"

"1150640792"

msgstr ""

msgid ""

"Here is a more advanced example, it uses the :func:`!strchr` function, which "

"expects a string pointer and a char, and returns a pointer to a string::"

msgstr ""

msgid ""

">>> strchr = libc.strchr\n"

">>> strchr(b\"abcdef\", ord(\"d\"))\n"

"8059983\n"

">>> strchr.restype = c_char_p # c_char_p is a pointer to a string\n"

">>> strchr(b\"abcdef\", ord(\"d\"))\n"

"b'def'\n"

">>> print(strchr(b\"abcdef\", ord(\"x\")))\n"

"None\n"

">>>"

msgstr ""

msgid ""

"If you want to avoid the :func:`ord(\"x\") <ord>` calls above, you can set "

"the :attr:`~_CFuncPtr.argtypes` attribute, and the second argument will be "

"converted from a single character Python bytes object into a C char:"

msgstr ""

msgid ""

">>> strchr.restype = c_char_p\n"

">>> strchr.argtypes = [c_char_p, c_char]\n"

">>> strchr(b\"abcdef\", b\"d\")\n"

"b'def'\n"

">>> strchr(b\"abcdef\", b\"def\")\n"

"Traceback (most recent call last):\n"

"ctypes.ArgumentError: argument 2: TypeError: one character bytes, bytearray "

"or integer expected\n"

">>> print(strchr(b\"abcdef\", b\"x\"))\n"

"None\n"

">>> strchr(b\"abcdef\", b\"d\")\n"

"b'def'\n"

">>>"

msgstr ""

msgid ""

"You can also use a callable Python object (a function or a class for "

"example) as the :attr:`~_CFuncPtr.restype` attribute, if the foreign "

"function returns an integer. The callable will be called with the *integer* "

"the C function returns, and the result of this call will be used as the "

"result of your function call. This is useful to check for error return "

"values and automatically raise an exception::"

msgstr ""

msgid ""

">>> GetModuleHandle = windll.kernel32.GetModuleHandleA\n"

">>> def ValidHandle(value):\n"

"... if value == 0:\n"

"... raise WinError()\n"

"... return value\n"

"...\n"

">>>\n"

">>> GetModuleHandle.restype = ValidHandle\n"

">>> GetModuleHandle(None)\n"

"486539264\n"

">>> GetModuleHandle(\"something silly\")\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" File \"<stdin>\", line 3, in ValidHandle\n"

"OSError: [Errno 126] The specified module could not be found.\n"

">>>"

msgstr ""