# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2026, Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-04-15 15:54+0000\n"

"PO-Revision-Date: 2025-09-15 01:04+0000\n"

"Last-Translator: python-doc bot, 2025\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 "ctypes tutorial"

msgstr ""

msgid ""

"Note: The code samples in this tutorial use :mod:`doctest` to make sure that "

"they actually work. Since some code samples behave differently under Linux, "

"Windows, or macOS, they contain doctest directives in comments."

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 *cdll*, and on Windows *windll* and *oledll* "

"objects, for loading dynamic link libraries."

msgstr ""

msgid ""

"You load libraries by accessing them as attributes of these objects. *cdll* "

"loads libraries which export functions using the standard ``cdecl`` calling "

"convention, while *windll* libraries call functions using the ``stdcall`` "

"calling convention. *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 ""

"On Linux, it is required to specify 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 "

"CDLL by calling the constructor::"

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 "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 ":class:`c_bool`"

msgstr ":class:`c_bool`"

msgid ":c:expr:`_Bool`"

msgstr ":c:expr:`_Bool`"

msgid "bool (1)"

msgstr ""

msgid ":class:`c_char`"

msgstr ":class:`c_char`"

msgid ":c:expr:`char`"

msgstr ":c:expr:`char`"

msgid "1-character bytes object"

msgstr ""

msgid ":class:`c_wchar`"

msgstr ":class:`c_wchar`"

msgid ":c:type:`wchar_t`"

msgstr ":c:type:`wchar_t`"

msgid "1-character string"

msgstr ""

msgid ":class:`c_byte`"

msgstr ":class:`c_byte`"

msgid "int"

msgstr "int"

msgid ":class:`c_ubyte`"

msgstr ":class:`c_ubyte`"

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

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

msgid ":class:`c_short`"

msgstr ":class:`c_short`"

msgid ":c:expr:`short`"

msgstr ":c:expr:`short`"

msgid ":class:`c_ushort`"

msgstr ":class:`c_ushort`"

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

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

msgid ":class:`c_int`"

msgstr ":class:`c_int`"

msgid ":c:expr:`int`"

msgstr ":c:expr:`int`"

msgid ":class:`c_int8`"

msgstr ""

msgid ":c:type:`int8_t`"

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 ":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 ":class:`c_ulong`"

msgstr ":class:`c_ulong`"

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

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

msgid ":class:`c_longlong`"

msgstr ":class:`c_longlong`"

msgid ":c:expr:`__int64` or :c:expr:`long long`"

msgstr ""

msgid ":class:`c_ulonglong`"

msgstr ":class:`c_ulonglong`"

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

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:`ssize_t` or :c:expr:`Py_ssize_t`"

msgstr ""

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 "float"

msgstr "typ (float) zmiennoprzecinkowy pojedynczej precyzji"

msgid ":class:`c_double`"

msgstr ":class:`c_double`"

msgid ":c:expr:`double`"

msgstr ":c:expr:`double`"

msgid ":class:`c_longdouble`"

msgstr ":class:`c_longdouble`"

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

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

msgid ":class:`c_char_p`"

msgstr ":class:`c_char_p`"

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

msgstr ""

msgid "bytes object or ``None``"

msgstr ""

msgid ":class:`c_wchar_p`"

msgstr ":class:`c_wchar_p`"

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

msgstr ""

msgid "string or ``None``"

msgstr ""

msgid ":class:`c_void_p`"

msgstr ":class:`c_void_p`"

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

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

msgid "int or ``None``"

msgstr ""

msgid "The constructor accepts any object with a truth value."

msgstr ""

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 ""

"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 ""

msgid ""

"``WinError`` is a function which will call Windows ``FormatMessage()`` api "

"to get the string representation of an error code, and *returns* an "

"exception. ``WinError`` takes an optional error code parameter, if no one is "

"used, it calls :func:`GetLastError` to retrieve it."

msgstr ""

msgid ""

"Please note that a much more powerful error checking mechanism is available "

"through the :attr:`~_CFuncPtr.errcheck` attribute; see the reference manual "

"for details."

msgstr ""

msgid "Passing pointers (or: passing parameters by reference)"

msgstr ""

msgid ""

"Sometimes a C api function expects a *pointer* to a data type as parameter, "

"probably to write into the corresponding location, or if the data is too "

"large to be passed by value. This is also known as *passing parameters by "

"reference*."

msgstr ""

msgid ""

":mod:`ctypes` exports the :func:`byref` function which is used to pass "

"parameters by reference. The same effect can be achieved with the :func:"

"`pointer` function, although :func:`pointer` does a lot more work since it "

"constructs a real pointer object, so it is faster to use :func:`byref` if "

"you don't need the pointer object in Python itself::"

msgstr ""

msgid ""

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

">>> f = c_float()\n"

">>> s = create_string_buffer(b'\\000' * 32)\n"

">>> print(i.value, f.value, repr(s.value))\n"

"0 0.0 b''\n"

">>> libc.sscanf(b\"1 3.14 Hello\", b\"%d %f %s\",\n"

"... byref(i), byref(f), s)\n"

"3\n"

">>> print(i.value, f.value, repr(s.value))\n"

"1 3.1400001049 b'Hello'\n"

">>>"

msgstr ""

msgid "Structures and unions"

msgstr ""

msgid ""

"Structures and unions must derive from the :class:`Structure` and :class:"

"`Union` base classes which are defined in the :mod:`ctypes` module. Each "

"subclass must define a :attr:`~Structure._fields_` attribute. :attr:`!"

"_fields_` must be a list of *2-tuples*, containing a *field name* and a "

"*field type*."

msgstr ""

msgid ""

"The field type must be a :mod:`ctypes` type like :class:`c_int`, or any "

"other derived :mod:`ctypes` type: structure, union, array, pointer."

msgstr ""

msgid ""

"Here is a simple example of a POINT structure, which contains two integers "

"named *x* and *y*, and also shows how to initialize a structure in the "

"constructor::"

msgstr ""

msgid ""

">>> from ctypes import *\n"

">>> class POINT(Structure):\n"

"... _fields_ = [(\"x\", c_int),\n"

"... (\"y\", c_int)]\n"

"...\n"

">>> point = POINT(10, 20)\n"

">>> print(point.x, point.y)\n"

"10 20\n"

">>> point = POINT(y=5)\n"

">>> print(point.x, point.y)\n"

"0 5\n"

">>> POINT(1, 2, 3)\n"

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

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

"TypeError: too many initializers\n"

">>>"

msgstr ""

msgid ""

"You can, however, build much more complicated structures. A structure can "

"itself contain other structures by using a structure as a field type."

msgstr ""

msgid ""

"Here is a RECT structure which contains two POINTs named *upperleft* and "

"*lowerright*::"

msgstr ""

msgid ""

">>> class RECT(Structure):\n"

"... _fields_ = [(\"upperleft\", POINT),\n"

"... (\"lowerright\", POINT)]\n"

"...\n"

">>> rc = RECT(point)\n"

">>> print(rc.upperleft.x, rc.upperleft.y)\n"

"0 5\n"

">>> print(rc.lowerright.x, rc.lowerright.y)\n"

"0 0\n"

">>>"

msgstr ""

msgid ""

"Nested structures can also be initialized in the constructor in several "

"ways::"

msgstr ""

msgid ""

">>> r = RECT(POINT(1, 2), POINT(3, 4))\n"

">>> r = RECT((1, 2), (3, 4))"

msgstr ""

msgid ""

"Field :term:`descriptor`\\s can be retrieved from the *class*, they are "

"useful for debugging because they can provide useful information::"

msgstr ""

msgid ""

">>> print(POINT.x)\n"

"<Field type=c_long, ofs=0, size=4>\n"

">>> print(POINT.y)\n"

"<Field type=c_long, ofs=4, size=4>\n"

">>>"

msgstr ""

">>> print(POINT.x)\n"

"<Field type=c_long, ofs=0, size=4>\n"

">>> print(POINT.y)\n"

"<Field type=c_long, ofs=4, size=4>\n"

">>>"

msgid ""

":mod:`ctypes` does not support passing unions or structures with bit-fields "

"to functions by value. While this may work on 32-bit x86, it's not "

"guaranteed by the library to work in the general case. Unions and "

"structures with bit-fields should always be passed to functions by pointer."

msgstr ""

msgid "Structure/union alignment and byte order"

msgstr ""

msgid ""

"By default, Structure and Union fields are aligned in the same way the C "

"compiler does it. It is possible to override this behavior by specifying a :"

"attr:`~Structure._pack_` class attribute in the subclass definition. This "

"must be set to a positive integer and specifies the maximum alignment for "