# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2021, 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>, 2020

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2021-01-01 16:06+0000\n"

"PO-Revision-Date: 2020-05-30 11:59+0000\n"

"Last-Translator: Maciej Olko <maciej.olko@gmail.com>, 2020\n"

"Language-Team: Polish (https://www.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 ""

":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 Mac OS X, 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 "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:`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 "Accessing functions from loaded dlls"

msgstr ""

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

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

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

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

msgstr ""

msgid ""

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

"uses the ``time()`` function, which returns system time in seconds since the "

"Unix epoch, and the ``GetModuleHandleA()`` function, which returns a win32 "

"module handle."

msgstr ""

msgid ""

"This example calls both functions with a ``NULL`` pointer (``None`` should "

"be used as the ``NULL`` pointer)::"

msgstr ""

msgid ""

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

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

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

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

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

"platforms default C :c:type:`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 ""

msgid ":c:type:`_Bool`"

msgstr ""

msgid "bool (1)"

msgstr ""

msgid ":class:`c_char`"

msgstr ""

msgid ":c:type:`char`"

msgstr ""

msgid "1-character bytes object"

msgstr ""

msgid ":class:`c_wchar`"

msgstr ""

msgid ":c:type:`wchar_t`"

msgstr ""

msgid "1-character string"

msgstr ""

msgid ":class:`c_byte`"

msgstr ""

msgid "int"

msgstr "int"

msgid ":class:`c_ubyte`"

msgstr ""

msgid ":c:type:`unsigned char`"

msgstr ""

msgid ":class:`c_short`"

msgstr ""

msgid ":c:type:`short`"

msgstr ""

msgid ":class:`c_ushort`"

msgstr ""

msgid ":c:type:`unsigned short`"

msgstr ""

msgid ":class:`c_int`"

msgstr ""

msgid ":c:type:`int`"

msgstr ""

msgid ":class:`c_uint`"

msgstr ""

msgid ":c:type:`unsigned int`"

msgstr ""

msgid ":class:`c_long`"

msgstr ""

msgid ":c:type:`long`"

msgstr ""

msgid ":class:`c_ulong`"

msgstr ""

msgid ":c:type:`unsigned long`"

msgstr ""

msgid ":class:`c_longlong`"

msgstr ""

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

msgstr ""

msgid ":class:`c_ulonglong`"

msgstr ""

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

msgstr ""

msgid ":class:`c_size_t`"

msgstr ""

msgid ":c:type:`size_t`"

msgstr ""

msgid ":class:`c_ssize_t`"

msgstr ""

msgid ":c:type:`ssize_t` or :c:type:`Py_ssize_t`"

msgstr ""

msgid ":class:`c_float`"

msgstr ""

msgid ":c:type:`float`"

msgstr ""

msgid "float"

msgstr "typ (float) zmiennoprzecinkowy pojedynczej precyzji"

msgid ":class:`c_double`"

msgstr ""

msgid ":c:type:`double`"

msgstr ""

msgid ":class:`c_longdouble`"

msgstr ""

msgid ":c:type:`long double`"

msgstr ""

msgid ":class:`c_char_p`"

msgstr ""

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

msgstr ""

msgid "bytes object or ``None``"

msgstr ""

msgid ":class:`c_wchar_p`"

msgstr ""

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

msgstr ""

msgid "string or ``None``"

msgstr ""

msgid ":class:`c_void_p`"

msgstr ""

msgid ":c:type:`void *`"

msgstr ""

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

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

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 bytes objects are immutable)::"

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

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

"function (which is still available as an alias), as well as the :func:"

"`c_string` function from earlier ctypes releases. 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 ""

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

"Of course, it must be one of integer, string, or bytes::"

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:`argtypes` attribute."

msgstr ""

msgid ""

":attr:`argtypes` must be a sequence of C data types (the ``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 ""

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

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

"have to implement a :meth:`from_param` class method for them to be able to "

"use them in the :attr:`argtypes` sequence. The :meth:`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:type:`int` type. Other "

"return types can be specified by setting the :attr:`restype` attribute of "

"the function object."

msgstr ""

msgid ""

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

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

msgstr ""

msgid ""

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

"`argtypes` attribute, and the second argument will be converted from a "

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

msgstr ""

msgid ""

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

"example) as the :attr:`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 ""

"``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:`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 "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:`_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 ""

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

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

"ways::"

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

":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:`_pack_` class attribute in the subclass definition. This must be set "

"to a positive integer and specifies the maximum alignment for the fields. "

"This is what ``#pragma pack(n)`` also does in MSVC."

msgstr ""

msgid ""

":mod:`ctypes` uses the native byte order for Structures and Unions. To "

"build structures with non-native byte order, you can use one of the :class:"

"`BigEndianStructure`, :class:`LittleEndianStructure`, :class:"

"`BigEndianUnion`, and :class:`LittleEndianUnion` base classes. These "

"classes cannot contain pointer fields."

msgstr ""

msgid "Bit fields in structures and unions"

msgstr ""

msgid ""

"It is possible to create structures and unions containing bit fields. Bit "

"fields are only possible for integer fields, the bit width is specified as "

"the third item in the :attr:`_fields_` tuples::"

msgstr ""

msgid "Arrays"

msgstr ""

msgid ""

"Arrays are sequences, containing a fixed number of instances of the same "

"type."

msgstr ""

msgid ""

"The recommended way to create array types is by multiplying a data type with "

"a positive integer::"

msgstr ""

msgid ""

"Here is an example of a somewhat artificial data type, a structure "

"containing 4 POINTs among other stuff::"

msgstr ""

msgid "Instances are created in the usual way, by calling the class::"

msgstr ""

msgid ""

"The above code print a series of ``0 0`` lines, because the array contents "

"is initialized to zeros."

msgstr ""

msgid "Initializers of the correct type can also be specified::"

msgstr ""

msgid "Pointers"

msgstr ""

msgid ""

"Pointer instances are created by calling the :func:`pointer` function on a :"

"mod:`ctypes` type::"

msgstr ""

msgid ""

"Pointer instances have a :attr:`~_Pointer.contents` attribute which returns "

"the object to which the pointer points, the ``i`` object above::"

msgstr ""

msgid ""

"Note that :mod:`ctypes` does not have OOR (original object return), it "

"constructs a new, equivalent object each time you retrieve an attribute::"

msgstr ""

msgid ""

"Assigning another :class:`c_int` instance to the pointer's contents "

"attribute would cause the pointer to point to the memory location where this "

"is stored::"

msgstr ""

msgid "Pointer instances can also be indexed with integers::"

msgstr ""

msgid "Assigning to an integer index changes the pointed to value::"

msgstr ""

msgid ""

"It is also possible to use indexes different from 0, but you must know what "

"you're doing, just as in C: You can access or change arbitrary memory "

"locations. Generally you only use this feature if you receive a pointer from "

"a C function, and you *know* that the pointer actually points to an array "

"instead of a single item."

msgstr ""

msgid ""

"Behind the scenes, the :func:`pointer` function does more than simply create "

"pointer instances, it has to create pointer *types* first. This is done with "

"the :func:`POINTER` function, which accepts any :mod:`ctypes` type, and "

"returns a new type::"

msgstr ""

msgid ""

"Calling the pointer type without an argument creates a ``NULL`` pointer. "

"``NULL`` pointers have a ``False`` boolean value::"

msgstr ""

msgid ""

":mod:`ctypes` checks for ``NULL`` when dereferencing pointers (but "

"dereferencing invalid non-\\ ``NULL`` pointers would crash Python)::"

msgstr ""

msgid "Type conversions"

msgstr ""

msgid ""

"Usually, ctypes does strict type checking. This means, if you have "

"``POINTER(c_int)`` in the :attr:`argtypes` list of a function or as the type "

"of a member field in a structure definition, only instances of exactly the "

"same type are accepted. There are some exceptions to this rule, where "

"ctypes accepts other objects. For example, you can pass compatible array "

"instances instead of pointer types. So, for ``POINTER(c_int)``, ctypes "

"accepts an array of c_int::"

msgstr ""

msgid ""

"In addition, if a function argument is explicitly declared to be a pointer "

"type (such as ``POINTER(c_int)``) in :attr:`argtypes`, an object of the "

"pointed type (``c_int`` in this case) can be passed to the function. ctypes "

"will apply the required :func:`byref` conversion in this case automatically."

msgstr ""

msgid "To set a POINTER type field to ``NULL``, you can assign ``None``::"

msgstr ""

msgid ""

"Sometimes you have instances of incompatible types. In C, you can cast one "

"type into another type. :mod:`ctypes` provides a :func:`cast` function "

"which can be used in the same way. The ``Bar`` structure defined above "

"accepts ``POINTER(c_int)`` pointers or :class:`c_int` arrays for its "

"``values`` field, but not instances of other types::"

msgstr ""

msgid "For these cases, the :func:`cast` function is handy."

msgstr ""

msgid ""

"The :func:`cast` function can be used to cast a ctypes instance into a "

"pointer to a different ctypes data type. :func:`cast` takes two parameters, "

"a ctypes object that is or can be converted to a pointer of some kind, and a "

"ctypes pointer type. It returns an instance of the second argument, which "

"references the same memory block as the first argument::"

msgstr ""

msgid ""

"So, :func:`cast` can be used to assign to the ``values`` field of ``Bar`` "

"the structure::"

msgstr ""

msgid "Incomplete Types"

msgstr ""

msgid ""

"*Incomplete Types* are structures, unions or arrays whose members are not "

"yet specified. In C, they are specified by forward declarations, which are "

"defined later::"

msgstr ""

msgid ""

"The straightforward translation into ctypes code would be this, but it does "

"not work::"

msgstr ""

msgid ""

"because the new ``class cell`` is not available in the class statement "

"itself. In :mod:`ctypes`, we can define the ``cell`` class and set the :attr:"

"`_fields_` attribute later, after the class statement::"

msgstr ""

msgid ""

"Let's try it. We create two instances of ``cell``, and let them point to "

"each other, and finally follow the pointer chain a few times::"

msgstr ""

msgid "Callback functions"

msgstr ""

msgid ""

":mod:`ctypes` allows creating C callable function pointers from Python "

"callables. These are sometimes called *callback functions*."

msgstr ""

msgid ""

"First, you must create a class for the callback function. The class knows "

"the calling convention, the return type, and the number and types of "

"arguments this function will receive."

msgstr ""

msgid ""

"The :func:`CFUNCTYPE` factory function creates types for callback functions "

"using the ``cdecl`` calling convention. On Windows, the :func:`WINFUNCTYPE` "

"factory function creates types for callback functions using the ``stdcall`` "

"calling convention."

msgstr ""

msgid ""

"Both of these factory functions are called with the result type as first "

"argument, and the callback functions expected argument types as the "

"remaining arguments."

msgstr ""

msgid ""

"I will present an example here which uses the standard C library's :c:func:"

"`qsort` function, that is used to sort items with the help of a callback "

"function. :c:func:`qsort` will be used to sort an array of integers::"

msgstr ""

msgid ""

":func:`qsort` must be called with a pointer to the data to sort, the number "

"of items in the data array, the size of one item, and a pointer to the "

"comparison function, the callback. The callback will then be called with two "

"pointers to items, and it must return a negative integer if the first item "

"is smaller than the second, a zero if they are equal, and a positive integer "

"otherwise."

msgstr ""

msgid ""

"So our callback function receives pointers to integers, and must return an "

"integer. First we create the ``type`` for the callback function::"

msgstr ""

msgid ""

"To get started, here is a simple callback that shows the values it gets "

"passed::"

msgstr ""

msgid "The result::"

msgstr ""

msgid "Now we can actually compare the two items and return a useful result::"

msgstr ""

msgid "As we can easily check, our array is sorted now::"

msgstr ""

msgid ""

"The function factories can be used as decorator factories, so we may as well "

"write::"

msgstr ""

msgid ""

"Make sure you keep references to :func:`CFUNCTYPE` objects as long as they "

"are used from C code. :mod:`ctypes` doesn't, and if you don't, they may be "

"garbage collected, crashing your program when a callback is made."

msgstr ""

msgid ""

"Also, note that if the callback function is called in a thread created "

"outside of Python's control (e.g. by the foreign code that calls the "

"callback), ctypes creates a new dummy Python thread on every invocation. "

"This behavior is correct for most purposes, but it means that values stored "

"with :class:`threading.local` will *not* survive across different callbacks, "

"even when those calls are made from the same C thread."

msgstr ""

msgid "Accessing values exported from dlls"

msgstr ""

msgid ""

"Some shared libraries not only export functions, they also export variables. "

"An example in the Python library itself is the :c:data:`Py_OptimizeFlag`, an "

"integer set to 0, 1, or 2, depending on the :option:`-O` or :option:`-OO` "

"flag given on startup."

msgstr ""

msgid ""

":mod:`ctypes` can access values like this with the :meth:`in_dll` class "

"methods of the type. *pythonapi* is a predefined symbol giving access to "

"the Python C api::"

msgstr ""

msgid ""

"If the interpreter would have been started with :option:`-O`, the sample "

"would have printed ``c_long(1)``, or ``c_long(2)`` if :option:`-OO` would "

"have been specified."

msgstr ""

msgid ""

"An extended example which also demonstrates the use of pointers accesses "

"the :c:data:`PyImport_FrozenModules` pointer exported by Python."

msgstr ""

msgid "Quoting the docs for that value:"

msgstr ""

msgid ""

"This pointer is initialized to point to an array of :c:type:`struct _frozen` "

"records, terminated by one whose members are all ``NULL`` or zero. When a "

"frozen module is imported, it is searched in this table. Third-party code "

"could play tricks with this to provide a dynamically created collection of "

"frozen modules."

msgstr ""

msgid ""

"So manipulating this pointer could even prove useful. To restrict the "

"example size, we show only how this table can be read with :mod:`ctypes`::"

msgstr ""

msgid ""

"We have defined the :c:type:`struct _frozen` data type, so we can get the "

"pointer to the table::"

msgstr ""

msgid ""

"Since ``table`` is a ``pointer`` to the array of ``struct_frozen`` records, "

"we can iterate over it, but we just have to make sure that our loop "

"terminates, because pointers have no size. Sooner or later it would probably "

"crash with an access violation or whatever, so it's better to break out of "

"the loop when we hit the ``NULL`` entry::"

msgstr ""

msgid ""

"The fact that standard Python has a frozen module and a frozen package "

"(indicated by the negative ``size`` member) is not well known, it is only "

"used for testing. Try it out with ``import __hello__`` for example."

msgstr ""

msgid "Surprises"

msgstr ""

msgid ""

"There are some edges in :mod:`ctypes` where you might expect something other "

"than what actually happens."

msgstr ""

msgid "Consider the following example::"

msgstr ""

msgid ""

"Hm. We certainly expected the last statement to print ``3 4 1 2``. What "

"happened? Here are the steps of the ``rc.a, rc.b = rc.b, rc.a`` line above::"

msgstr ""

msgid ""

"Note that ``temp0`` and ``temp1`` are objects still using the internal "

"buffer of the ``rc`` object above. So executing ``rc.a = temp0`` copies the "

"buffer contents of ``temp0`` into ``rc`` 's buffer. This, in turn, changes "

"the contents of ``temp1``. So, the last assignment ``rc.b = temp1``, doesn't "

"have the expected effect."

msgstr ""

msgid ""

"Keep in mind that retrieving sub-objects from Structure, Unions, and Arrays "

"doesn't *copy* the sub-object, instead it retrieves a wrapper object "

"accessing the root-object's underlying buffer."

msgstr ""

msgid ""

"Another example that may behave differently from what one would expect is "

"this::"

msgstr ""

msgid ""

"Objects instantiated from :class:`c_char_p` can only have their value set to "

"bytes or integers."

msgstr ""

msgid ""

"Why is it printing ``False``? ctypes instances are objects containing a "

"memory block plus some :term:`descriptor`\\s accessing the contents of the "

"memory. Storing a Python object in the memory block does not store the "

"object itself, instead the ``contents`` of the object is stored. Accessing "

"the contents again constructs a new Python object each time!"

msgstr ""

msgid "Variable-sized data types"

msgstr ""

msgid ""

":mod:`ctypes` provides some support for variable-sized arrays and structures."

msgstr ""

msgid ""

"The :func:`resize` function can be used to resize the memory buffer of an "

"existing ctypes object. The function takes the object as first argument, "

"and the requested size in bytes as the second argument. The memory block "

"cannot be made smaller than the natural memory block specified by the "

"objects type, a :exc:`ValueError` is raised if this is tried::"

msgstr ""

msgid ""

"This is nice and fine, but how would one access the additional elements "

"contained in this array? Since the type still only knows about 4 elements, "

"we get errors accessing other elements::"

msgstr ""

msgid ""

"Another way to use variable-sized data types with :mod:`ctypes` is to use "

"the dynamic nature of Python, and (re-)define the data type after the "

"required size is already known, on a case by case basis."

msgstr ""

msgid "ctypes reference"

msgstr ""

msgid "Finding shared libraries"

msgstr ""

msgid ""

"When programming in a compiled language, shared libraries are accessed when "

"compiling/linking a program, and when the program is run."

msgstr ""

msgid ""

"The purpose of the :func:`find_library` function is to locate a library in a "

"way similar to what the compiler or runtime loader does (on platforms with "

"several versions of a shared library the most recent should be loaded), "

"while the ctypes library loaders act like when a program is run, and call "

"the runtime loader directly."

msgstr ""

msgid ""

"The :mod:`ctypes.util` module provides a function which can help to "

"determine the library to load."

msgstr ""

msgid ""

"Try to find a library and return a pathname. *name* is the library name "

"without any prefix like *lib*, suffix like ``.so``, ``.dylib`` or version "

"number (this is the form used for the posix linker option :option:`!-l`). "

"If no library can be found, returns ``None``."

msgstr ""

msgid "The exact functionality is system dependent."

msgstr ""

msgid ""

"On Linux, :func:`find_library` tries to run external programs (``/sbin/"

"ldconfig``, ``gcc``, ``objdump`` and ``ld``) to find the library file. It "

"returns the filename of the library file."

msgstr ""

msgid ""

"On Linux, the value of the environment variable ``LD_LIBRARY_PATH`` is used "

"when searching for libraries, if a library cannot be found by any other "

"means."

msgstr ""