# 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-17 15:40+0000\n"

"PO-Revision-Date: 2025-09-15 01:03+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 "Extending Python with C or C++"

msgstr "Rozszerzanie Pythona za pomocą C lub C++"

msgid ""

"It is quite easy to add new built-in modules to Python, if you know how to "

"program in C. Such :dfn:`extension modules` can do two things that can't be "

"done directly in Python: they can implement new built-in object types, and "

"they can call C library functions and system calls."

msgstr ""

"Jest całkiem łatwo dodać nowe wbudowane moduły do Pythona, jeśli znasz się "

"na programowaniu w C. Takie :dfn:`moduły rozszerzające <extension modules>` "

"mogą zrobić dwie rzeczy których nie da się zrobić bezpośrednio w Pythonie: "

"mogą wypełnić nowe wbudowane typy przedmiotów i mogą odwołać się do zadań "

"bibliotecznych C i odwołań systemowych."

msgid ""

"To support extensions, the Python API (Application Programmers Interface) "

"defines a set of functions, macros and variables that provide access to most "

"aspects of the Python run-time system. The Python API is incorporated in a "

"C source file by including the header ``\"Python.h\"``."

msgstr ""

"Aby wspierać rozszerzenia, API Pythona (Application Programmers Interface) "

"określa zbiór funkcji, makropoleceń i zmiennych, które dostarczają dostęp do "

"większości aspektów systemu czasu-wykonania Pythona. API Pythona jest "

"załączane w źródłowym pliku C przez załączenie pliku nagłówkowego ``\"Python."

"h\"``."

msgid ""

"The compilation of an extension module depends on its intended use as well "

"as on your system setup; details are given in later chapters."

msgstr ""

"Kompilacja rozszerzających modułów zależy od jego zamierzonego użycia "

"zarówno jak też od ustawień twojego systemu; szczegóły są dane w "

"późniejszych rozdziałach."

msgid ""

"The C extension interface is specific to CPython, and extension modules do "

"not work on other Python implementations. In many cases, it is possible to "

"avoid writing C extensions and preserve portability to other "

"implementations. For example, if your use case is calling C library "

"functions or system calls, you should consider using the :mod:`ctypes` "

"module or the `cffi <https://cffi.readthedocs.io/>`_ library rather than "

"writing custom C code. These modules let you write Python code to interface "

"with C code and are more portable between implementations of Python than "

"writing and compiling a C extension module."

msgstr ""

msgid "A Simple Example"

msgstr "Prosty przykład"

msgid ""

"Let's create an extension module called ``spam`` (the favorite food of Monty "

"Python fans...) and let's say we want to create a Python interface to the C "

"library function :c:func:`system` [#]_. This function takes a null-"

"terminated character string as argument and returns an integer. We want "

"this function to be callable from Python as follows:"

msgstr ""

msgid ""

">>> import spam\n"

">>> status = spam.system(\"ls -l\")"

msgstr ""

">>> import spam\n"

">>> status = spam.system(\"ls -l\")"

msgid ""

"Begin by creating a file :file:`spammodule.c`. (Historically, if a module "

"is called ``spam``, the C file containing its implementation is called :file:"

"`spammodule.c`; if the module name is very long, like ``spammify``, the "

"module name can be just :file:`spammify.c`.)"

msgstr ""

"Zaczynając od stworzenia pliku :file:`spammodule.c` (Historycznie, jeśli "

"moduł był nazwany ``spam``, plik C zawierający jego wypełnienie jest "

"nazywany :file:`spammodule.c`; jeśli nazwa modułu jest bardzo długa, jak np "

"``spammify``, nazwa modułu może być po prostu :file:`spammify.c`.)"

msgid "The first two lines of our file can be::"

msgstr ""

msgid ""

"#define PY_SSIZE_T_CLEAN\n"

"#include <Python.h>"

msgstr ""

"#define PY_SSIZE_T_CLEAN\n"

"#include <Python.h>"

msgid ""

"which pulls in the Python API (you can add a comment describing the purpose "

"of the module and a copyright notice if you like)."

msgstr ""

"które dociągają API Pythona (możesz dodać komentarz opisujący przeznaczenie "

"modułu i uwagi na temat praw autorskich jeśli masz ochotę)."

msgid ""

"Since Python may define some pre-processor definitions which affect the "

"standard headers on some systems, you *must* include :file:`Python.h` before "

"any standard headers are included."

msgstr ""

"Jako że Python może definiować pewne definicje preprocesora, które wpływają "

"na pliki nagłówkowe na niektórych systemach, *musisz* załączyć plik :file:"

"`Python.h` przed jakimikolwiek standardowymi nagłówkami."

msgid ""

"``#define PY_SSIZE_T_CLEAN`` was used to indicate that ``Py_ssize_t`` should "

"be used in some APIs instead of ``int``. It is not necessary since Python "

"3.13, but we keep it here for backward compatibility. See :ref:`arg-parsing-"

"string-and-buffers` for a description of this macro."

msgstr ""

msgid ""

"All user-visible symbols defined by :file:`Python.h` have a prefix of ``Py`` "

"or ``PY``, except those defined in standard header files."

msgstr ""

msgid ""

"For backward compatibility, :file:`Python.h` includes several standard "

"header files. C extensions should include the standard headers that they "

"use, and should not rely on these implicit includes. If using the limited C "

"API version 3.13 or newer, the implicit includes are:"

msgstr ""

msgid "``<assert.h>``"

msgstr ""

msgid "``<intrin.h>`` (on Windows)"

msgstr ""

msgid "``<inttypes.h>``"

msgstr ""

msgid "``<limits.h>``"

msgstr ""

msgid "``<math.h>``"

msgstr ""

msgid "``<stdarg.h>``"

msgstr ""

msgid "``<wchar.h>``"

msgstr ""

msgid "``<sys/types.h>`` (if present)"

msgstr ""

msgid ""

"If :c:macro:`Py_LIMITED_API` is not defined, or is set to version 3.12 or "

"older, the headers below are also included:"

msgstr ""

msgid "``<ctype.h>``"

msgstr ""

msgid "``<unistd.h>`` (on POSIX)"

msgstr ""

msgid ""

"If :c:macro:`Py_LIMITED_API` is not defined, or is set to version 3.10 or "

"older, the headers below are also included:"

msgstr ""

msgid "``<errno.h>``"

msgstr ""

msgid "``<stdio.h>``"

msgstr ""

msgid "``<stdlib.h>``"

msgstr ""

msgid "``<string.h>``"

msgstr ""

msgid ""

"The next thing we add to our module file is the C function that will be "

"called when the Python expression ``spam.system(string)`` is evaluated "

"(we'll see shortly how it ends up being called)::"

msgstr ""

"Następną rzeczą którą dodajemy do naszego pliku modułu jest zadanie C które "

"będzie wzywane gdy wyrażenie języka pytonowskiego ``spam.system(string)`` "

"zostanie obliczone (zobaczymy niedługo, jak to się kończy wywołaniem)::"

msgid ""

"static PyObject *\n"

"spam_system(PyObject *self, PyObject *args)\n"

"{\n"

" const char *command;\n"

" int sts;\n"

"\n"

" if (!PyArg_ParseTuple(args, \"s\", &command))\n"

" return NULL;\n"

" sts = system(command);\n"

" return PyLong_FromLong(sts);\n"

"}"

msgstr ""

msgid ""

"There is a straightforward translation from the argument list in Python (for "

"example, the single expression ``\"ls -l\"``) to the arguments passed to the "

"C function. The C function always has two arguments, conventionally named "

"*self* and *args*."

msgstr ""

"Istnieje prosta zamiana nazw z listy parametrów w języku pytonowskim (dla "

"przykładu, pojedyncze wyrażenie ``\"ls -l\"``) do parametrów przekazanych do "

"zadania C. Zadanie C zawsze ma dwa parametry, dla wygody nazywane *sam* - z "

"ang. - *self* i *args*."

msgid ""

"The *self* argument points to the module object for module-level functions; "

"for a method it would point to the object instance."

msgstr ""

"Parametr *sam* - z ang. - *self* - wskazuje na przedmiot modułu dla zadań na "

"poziomie-modułu; dla sposobu postępowania wskazywałby na przykład przedmiotu."

msgid ""

"The *args* argument will be a pointer to a Python tuple object containing "

"the arguments. Each item of the tuple corresponds to an argument in the "

"call's argument list. The arguments are Python objects --- in order to do "

"anything with them in our C function we have to convert them to C values. "

"The function :c:func:`PyArg_ParseTuple` in the Python API checks the "

"argument types and converts them to C values. It uses a template string to "

"determine the required types of the arguments as well as the types of the C "

"variables into which to store the converted values. More about this later."

msgstr ""

msgid ""

":c:func:`PyArg_ParseTuple` returns true (nonzero) if all arguments have the "

"right type and its components have been stored in the variables whose "

"addresses are passed. It returns false (zero) if an invalid argument list "

"was passed. In the latter case it also raises an appropriate exception so "

"the calling function can return ``NULL`` immediately (as we saw in the "

"example)."

msgstr ""

msgid "Intermezzo: Errors and Exceptions"

msgstr "Intermezzo: Błędy i Wyjątki"

msgid ""

"An important convention throughout the Python interpreter is the following: "

"when a function fails, it should set an exception condition and return an "

"error value (usually ``-1`` or a ``NULL`` pointer). Exception information "

"is stored in three members of the interpreter's thread state. These are "

"``NULL`` if there is no exception. Otherwise they are the C equivalents of "

"the members of the Python tuple returned by :meth:`sys.exc_info`. These are "

"the exception type, exception instance, and a traceback object. It is "

"important to know about them to understand how errors are passed around."

msgstr ""

msgid ""

"The Python API defines a number of functions to set various types of "

"exceptions."

msgstr ""

"Sprzęg języka pytonowskiego określa pewien zestaw zadań do ustawiania "

"różnych rodzajów wyjątków."

msgid ""

"The most common one is :c:func:`PyErr_SetString`. Its arguments are an "

"exception object and a C string. The exception object is usually a "

"predefined object like :c:data:`PyExc_ZeroDivisionError`. The C string "

"indicates the cause of the error and is converted to a Python string object "

"and stored as the \"associated value\" of the exception."

msgstr ""

msgid ""

"Another useful function is :c:func:`PyErr_SetFromErrno`, which only takes an "

"exception argument and constructs the associated value by inspection of the "

"global variable :c:data:`errno`. The most general function is :c:func:"

"`PyErr_SetObject`, which takes two object arguments, the exception and its "

"associated value. You don't need to :c:func:`Py_INCREF` the objects passed "

"to any of these functions."

msgstr ""

msgid ""

"You can test non-destructively whether an exception has been set with :c:"

"func:`PyErr_Occurred`. This returns the current exception object, or "

"``NULL`` if no exception has occurred. You normally don't need to call :c:"

"func:`PyErr_Occurred` to see whether an error occurred in a function call, "

"since you should be able to tell from the return value."

msgstr ""

msgid ""

"When a function *f* that calls another function *g* detects that the latter "

"fails, *f* should itself return an error value (usually ``NULL`` or "

"``-1``). It should *not* call one of the ``PyErr_*`` functions --- one has "

"already been called by *g*. *f*'s caller is then supposed to also return an "

"error indication to *its* caller, again *without* calling ``PyErr_*``, and "

"so on --- the most detailed cause of the error was already reported by the "

"function that first detected it. Once the error reaches the Python "

"interpreter's main loop, this aborts the currently executing Python code and "

"tries to find an exception handler specified by the Python programmer."

msgstr ""

msgid ""

"(There are situations where a module can actually give a more detailed error "

"message by calling another ``PyErr_*`` function, and in such cases it is "

"fine to do so. As a general rule, however, this is not necessary, and can "

"cause information about the cause of the error to be lost: most operations "

"can fail for a variety of reasons.)"

msgstr ""

msgid ""

"To ignore an exception set by a function call that failed, the exception "

"condition must be cleared explicitly by calling :c:func:`PyErr_Clear`. The "

"only time C code should call :c:func:`PyErr_Clear` is if it doesn't want to "

"pass the error on to the interpreter but wants to handle it completely by "

"itself (possibly by trying something else, or pretending nothing went wrong)."

msgstr ""

msgid ""

"Every failing :c:func:`malloc` call must be turned into an exception --- the "

"direct caller of :c:func:`malloc` (or :c:func:`realloc`) must call :c:func:"

"`PyErr_NoMemory` and return a failure indicator itself. All the object-"

"creating functions (for example, :c:func:`PyLong_FromLong`) already do this, "

"so this note is only relevant to those who call :c:func:`malloc` directly."

msgstr ""

msgid ""

"Also note that, with the important exception of :c:func:`PyArg_ParseTuple` "

"and friends, functions that return an integer status usually return a "

"positive value or zero for success and ``-1`` for failure, like Unix system "

"calls."

msgstr ""

msgid ""

"Finally, be careful to clean up garbage (by making :c:func:`Py_XDECREF` or :"

"c:func:`Py_DECREF` calls for objects you have already created) when you "

"return an error indicator!"

msgstr ""

msgid ""

"The choice of which exception to raise is entirely yours. There are "

"predeclared C objects corresponding to all built-in Python exceptions, such "

"as :c:data:`PyExc_ZeroDivisionError`, which you can use directly. Of course, "

"you should choose exceptions wisely --- don't use :c:data:`PyExc_TypeError` "

"to mean that a file couldn't be opened (that should probably be :c:data:"

"`PyExc_OSError`). If something's wrong with the argument list, the :c:func:"

"`PyArg_ParseTuple` function usually raises :c:data:`PyExc_TypeError`. If "

"you have an argument whose value must be in a particular range or must "

"satisfy other conditions, :c:data:`PyExc_ValueError` is appropriate."

msgstr ""

msgid ""

"You can also define a new exception that is unique to your module. The "

"simplest way to do this is to declare a static global object variable at the "

"beginning of the file::"

msgstr ""

msgid "static PyObject *SpamError = NULL;"

msgstr ""

msgid ""

"and initialize it by calling :c:func:`PyErr_NewException` in the module's :c:"

"data:`Py_mod_exec` function (:c:func:`!spam_module_exec`)::"

msgstr ""

msgid "SpamError = PyErr_NewException(\"spam.error\", NULL, NULL);"

msgstr ""

msgid ""

"Since :c:data:`!SpamError` is a global variable, it will be overwritten "

"every time the module is reinitialized, when the :c:data:`Py_mod_exec` "

"function is called."

msgstr ""

msgid ""

"For now, let's avoid the issue: we will block repeated initialization by "

"raising an :py:exc:`ImportError`::"

msgstr ""

msgid ""

"static PyObject *SpamError = NULL;\n"

"\n"

"static int\n"

"spam_module_exec(PyObject *m)\n"

"{\n"

" if (SpamError != NULL) {\n"

" PyErr_SetString(PyExc_ImportError,\n"

" \"cannot initialize spam module more than once\");\n"

" return -1;\n"

" }\n"

" SpamError = PyErr_NewException(\"spam.error\", NULL, NULL);\n"

" if (PyModule_AddObjectRef(m, \"SpamError\", SpamError) < 0) {\n"

" return -1;\n"

" }\n"

"\n"

" return 0;\n"

"}\n"

"\n"

"static PyModuleDef_Slot spam_module_slots[] = {\n"

" {Py_mod_exec, spam_module_exec},\n"

" {0, NULL}\n"

"};\n"

"\n"

"static struct PyModuleDef spam_module = {\n"

" .m_base = PyModuleDef_HEAD_INIT,\n"

" .m_name = \"spam\",\n"

" .m_size = 0, // non-negative\n"

" .m_slots = spam_module_slots,\n"

"};\n"

"\n"

"PyMODINIT_FUNC\n"

"PyInit_spam(void)\n"

"{\n"

" return PyModuleDef_Init(&spam_module);\n"

"}"

msgstr ""

msgid ""

"Note that the Python name for the exception object is :exc:`!spam.error`. "

"The :c:func:`PyErr_NewException` function may create a class with the base "

"class being :exc:`Exception` (unless another class is passed in instead of "

"``NULL``), described in :ref:`bltin-exceptions`."

msgstr ""

msgid ""

"Note also that the :c:data:`!SpamError` variable retains a reference to the "

"newly created exception class; this is intentional! Since the exception "

"could be removed from the module by external code, an owned reference to the "

"class is needed to ensure that it will not be discarded, causing :c:data:`!"

"SpamError` to become a dangling pointer. Should it become a dangling "

"pointer, C code which raises the exception could cause a core dump or other "

"unintended side effects."

msgstr ""

msgid ""

"For now, the :c:func:`Py_DECREF` call to remove this reference is missing. "

"Even when the Python interpreter shuts down, the global :c:data:`!SpamError` "

"variable will not be garbage-collected. It will \"leak\". We did, however, "

"ensure that this will happen at most once per process."

msgstr ""

msgid ""

"We discuss the use of :c:macro:`PyMODINIT_FUNC` as a function return type "

"later in this sample."

msgstr ""

msgid ""

"The :exc:`!spam.error` exception can be raised in your extension module "

"using a call to :c:func:`PyErr_SetString` as shown below::"

msgstr ""

msgid ""

"static PyObject *\n"

"spam_system(PyObject *self, PyObject *args)\n"

"{\n"

" const char *command;\n"

" int sts;\n"

"\n"

" if (!PyArg_ParseTuple(args, \"s\", &command))\n"

" return NULL;\n"

" sts = system(command);\n"

" if (sts < 0) {\n"

" PyErr_SetString(SpamError, \"System command failed\");\n"

" return NULL;\n"

" }\n"

" return PyLong_FromLong(sts);\n"

"}"

msgstr ""

msgid "Back to the Example"

msgstr "Z powrotem do Przykładu"

msgid ""

"Going back to our example function, you should now be able to understand "

"this statement::"

msgstr ""

"Wracając do naszej przykładowego zadania, powinieneś już być w stanie "

"zrozumieć to wyrażenie::"

msgid ""

"if (!PyArg_ParseTuple(args, \"s\", &command))\n"

" return NULL;"

msgstr ""

msgid ""

"It returns ``NULL`` (the error indicator for functions returning object "

"pointers) if an error is detected in the argument list, relying on the "

"exception set by :c:func:`PyArg_ParseTuple`. Otherwise the string value of "

"the argument has been copied to the local variable :c:data:`!command`. This "

"is a pointer assignment and you are not supposed to modify the string to "

"which it points (so in Standard C, the variable :c:data:`!command` should "

"properly be declared as ``const char *command``)."

msgstr ""

msgid ""

"The next statement is a call to the Unix function :c:func:`system`, passing "

"it the string we just got from :c:func:`PyArg_ParseTuple`::"

msgstr ""

msgid "sts = system(command);"

msgstr ""

msgid ""

"Our :func:`!spam.system` function must return the value of :c:data:`!sts` as "

"a Python object. This is done using the function :c:func:"

"`PyLong_FromLong`. ::"

msgstr ""

msgid "return PyLong_FromLong(sts);"

msgstr ""

msgid ""

"In this case, it will return an integer object. (Yes, even integers are "

"objects on the heap in Python!)"

msgstr ""

"W tym przypadku, zwróci przedmiot liczby całkowitej (Tak, nawet liczby "

"całkowite są przedmiotami na stercie w języku pytonowskim!)"

msgid ""

"If you have a C function that returns no useful argument (a function "

"returning :c:expr:`void`), the corresponding Python function must return "

"``None``. You need this idiom to do so (which is implemented by the :c:"

"macro:`Py_RETURN_NONE` macro)::"

msgstr ""

msgid ""

"Py_INCREF(Py_None);\n"

"return Py_None;"

msgstr ""

msgid ""

":c:data:`Py_None` is the C name for the special Python object ``None``. It "

"is a genuine Python object rather than a ``NULL`` pointer, which means "

"\"error\" in most contexts, as we have seen."

msgstr ""

msgid "The Module's Method Table and Initialization Function"

msgstr "Zadanie zainicjowania i tabela sposobów postępowania modułu."

msgid ""

"I promised to show how :c:func:`!spam_system` is called from Python "

"programs. First, we need to list its name and address in a \"method table\"::"

msgstr ""

msgid ""

"static PyMethodDef spam_methods[] = {\n"

" ...\n"

" {\"system\", spam_system, METH_VARARGS,\n"

" \"Execute a shell command.\"},\n"

" ...\n"

" {NULL, NULL, 0, NULL} /* Sentinel */\n"

"};"

msgstr ""

msgid ""

"Note the third entry (``METH_VARARGS``). This is a flag telling the "

"interpreter the calling convention to be used for the C function. It should "

"normally always be ``METH_VARARGS`` or ``METH_VARARGS | METH_KEYWORDS``; a "

"value of ``0`` means that an obsolete variant of :c:func:`PyArg_ParseTuple` "

"is used."

msgstr ""

msgid ""

"When using only ``METH_VARARGS``, the function should expect the Python-"

"level parameters to be passed in as a tuple acceptable for parsing via :c:"

"func:`PyArg_ParseTuple`; more information on this function is provided below."

msgstr ""

msgid ""

"The :c:macro:`METH_KEYWORDS` bit may be set in the third field if keyword "

"arguments should be passed to the function. In this case, the C function "

"should accept a third ``PyObject *`` parameter which will be a dictionary of "

"keywords. Use :c:func:`PyArg_ParseTupleAndKeywords` to parse the arguments "

"to such a function."

msgstr ""

msgid ""

"The method table must be referenced in the module definition structure::"

msgstr ""

"Tabela sposobów postępowania musi być określona w strukturze definicji "

"modułu::"

msgid ""

"static struct PyModuleDef spam_module = {\n"

" ...\n"

" .m_methods = spam_methods,\n"

" ...\n"

"};"

msgstr ""

msgid ""

"This structure, in turn, must be passed to the interpreter in the module's "

"initialization function. The initialization function must be named :c:func:"

"`!PyInit_name`, where *name* is the name of the module, and should be the "

"only non-\\ ``static`` item defined in the module file::"

msgstr ""

msgid ""

"PyMODINIT_FUNC\n"

"PyInit_spam(void)\n"

"{\n"

" return PyModuleDef_Init(&spam_module);\n"

"}"

msgstr ""

msgid ""

"Note that :c:macro:`PyMODINIT_FUNC` declares the function as ``PyObject *`` "

"return type, declares any special linkage declarations required by the "

"platform, and for C++ declares the function as ``extern \"C\"``."

msgstr ""

msgid ""

":c:func:`!PyInit_spam` is called when each interpreter imports its module :"

"mod:`!spam` for the first time. (See below for comments about embedding "

"Python.) A pointer to the module definition must be returned via :c:func:"

"`PyModuleDef_Init`, so that the import machinery can create the module and "

"store it in ``sys.modules``."

msgstr ""

msgid ""

"When embedding Python, the :c:func:`!PyInit_spam` function is not called "

"automatically unless there's an entry in the :c:data:`PyImport_Inittab` "

"table. To add the module to the initialization table, use :c:func:"

"`PyImport_AppendInittab`, optionally followed by an import of the module::"

msgstr ""

msgid ""

"#define PY_SSIZE_T_CLEAN\n"

"#include <Python.h>\n"

"\n"

"int\n"

"main(int argc, char *argv[])\n"

"{\n"

" PyStatus status;\n"

" PyConfig config;\n"

" PyConfig_InitPythonConfig(&config);\n"

"\n"

" /* Add a built-in module, before Py_Initialize */\n"

" if (PyImport_AppendInittab(\"spam\", PyInit_spam) == -1) {\n"

" fprintf(stderr, \"Error: could not extend in-built modules "

"table\\n\");\n"

" exit(1);\n"

" }\n"

"\n"

" /* Pass argv[0] to the Python interpreter */\n"

" status = PyConfig_SetBytesString(&config, &config.program_name, "

"argv[0]);\n"

" if (PyStatus_Exception(status)) {\n"

" goto exception;\n"

" }\n"

"\n"

" /* Initialize the Python interpreter. Required.\n"

" If this step fails, it will be a fatal error. */\n"

" status = Py_InitializeFromConfig(&config);\n"

" if (PyStatus_Exception(status)) {\n"

" goto exception;\n"

" }\n"

" PyConfig_Clear(&config);\n"

"\n"

" /* Optionally import the module; alternatively,\n"

" import can be deferred until the embedded script\n"

" imports it. */\n"

" PyObject *pmodule = PyImport_ImportModule(\"spam\");\n"

" if (!pmodule) {\n"

" PyErr_Print();\n"

" fprintf(stderr, \"Error: could not import module 'spam'\\n\");\n"

" }\n"

"\n"

" // ... use Python C API here ...\n"

"\n"

" return 0;\n"

"\n"

" exception:\n"

" PyConfig_Clear(&config);\n"

" Py_ExitStatusException(status);\n"

"}"

msgstr ""

msgid ""

"If you declare a global variable or a local static one, the module may "

"experience unintended side-effects on re-initialisation, for example when "

"removing entries from ``sys.modules`` or importing compiled modules into "

"multiple interpreters within a process (or following a :c:func:`fork` "

"without an intervening :c:func:`exec`). If module state is not yet fully :"

"ref:`isolated <isolating-extensions-howto>`, authors should consider marking "

"the module as having no support for subinterpreters (via :c:macro:"

"`Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED`)."

msgstr ""

msgid ""

"A more substantial example module is included in the Python source "

"distribution as :file:`Modules/xxlimited.c`. This file may be used as a "

"template or simply read as an example."

msgstr ""

msgid "Compilation and Linkage"

msgstr "Kompilacja i łączenie"

msgid ""

"There are two more things to do before you can use your new extension: "

"compiling and linking it with the Python system. If you use dynamic "

"loading, the details may depend on the style of dynamic loading your system "

"uses; see the chapters about building extension modules (chapter :ref:"

"`building`) and additional information that pertains only to building on "

"Windows (chapter :ref:`building-on-windows`) for more information about this."

msgstr ""

"Są jeszcze dwie rzeczy które trzeba zrobić zanim będzie można użyć nowego "

"rozszerzenia: skompilowanie go i podłączenie z systemem Pythona. Jeśli "

"używasz dynamicznego ładowania, szczegóły mogą zależeć od stylu dynamicznego "

"ładowania którego twój system używa; zobacz rozdział o budowaniu "

"rozszerzających modułów (rozdział :ref:`building`) i dodatkowe informacje "

"które odnoszą się tylko do budowania w Windows (rozdział :ref:`building-on-"

"windows`) po więcej informacji na ten temat."

msgid ""

"If you can't use dynamic loading, or if you want to make your module a "

"permanent part of the Python interpreter, you will have to change the "

"configuration setup and rebuild the interpreter. Luckily, this is very "

"simple on Unix: just place your file (:file:`spammodule.c` for example) in "

"the :file:`Modules/` directory of an unpacked source distribution, add a "

"line to the file :file:`Modules/Setup.local` describing your file:"

msgstr ""

msgid "spam spammodule.o"

msgstr ""

msgid ""

"and rebuild the interpreter by running :program:`make` in the toplevel "

"directory. You can also run :program:`make` in the :file:`Modules/` "

"subdirectory, but then you must first rebuild :file:`Makefile` there by "

"running ':program:`make` Makefile'. (This is necessary each time you change "

"the :file:`Setup` file.)"

msgstr ""

"i przebuduj program interpretujący przez uruchomienie programu :program:"

"`make` w katalogu głównym instalacji. Możesz także uruchomić program :"

"program:`make` w podkatalogu :file:`Modules/`, ale wtedy musisz najpierw "

"przebudować plik :file:`Makefile` tam przez uruchomienie programu :program:"

"`make` Makefile'. To jest konieczne za każdym razem gdy zmieniasz plik :file:"

"`Setup`.)"

msgid ""

"If your module requires additional libraries to link with, these can be "

"listed on the line in the configuration file as well, for instance:"

msgstr ""

msgid "spam spammodule.o -lX11"

msgstr ""

msgid "Calling Python Functions from C"

msgstr "Wywoływanie zadań języka pytonowskiego z C"

msgid ""

"So far we have concentrated on making C functions callable from Python. The "

"reverse is also useful: calling Python functions from C. This is especially "

"the case for libraries that support so-called \"callback\" functions. If a "

"C interface makes use of callbacks, the equivalent Python often needs to "

"provide a callback mechanism to the Python programmer; the implementation "

"will require calling the Python callback functions from a C callback. Other "

"uses are also imaginable."

msgstr ""

"Jak do tej pory koncentrowaliśmy się na uczynieniu zadań C możliwymi do "

"wywołania z poziomu języka pytonowskiego. Odwrotna sytuacja jest także "

"użyteczna: wywoływanie zadań języka pytonowskiego z poziomu języka C. To w "

"szczególności odnosi się do bibliotek które wspierają tak zwane zadania "

"\"callback\" wstecznie wywołujące. Jeśli sprzęg C używa zadań wstecznie "

"wywołujących, odpowiednik języka pytonowskiego często potrzebuje dostarczyć "

"mechanizm wstecznego wywołania dla programisty języka pytonowskiego; "

"wypełnienie będzie potrzebowało wzywać zadania wywołania wstecznego z "

"poziomu wstecznego C. Inne przypadki są także możliwe do wyobrażenia."

msgid ""

"Fortunately, the Python interpreter is easily called recursively, and there "

"is a standard interface to call a Python function. (I won't dwell on how to "

"call the Python parser with a particular string as input --- if you're "

"interested, have a look at the implementation of the :option:`-c` command "

"line option in :file:`Modules/main.c` from the Python source code.)"

msgstr ""

"Szczęśliwie, program interpretujący polecenia języka pytonowskiego jest "

"łatwo wywoływany rekursywnie i istnieje standardowy sprzęg aby wywołać "

"zadanie języka pytonowskiego. (Nie będę rozpisywał się o tym jak wywołać "

"czytnik języka pytonowskiego z konkretnym ciągiem znaków na wejściu --- "

"jeśli jesteś zainteresowany, spójrz na wypełnienie opcji :option:`-c` "

"wiersza polecenia w :file:`Modules/main.c` z kodu źródłowego języka "

"pytonowskiego.)"

msgid ""

"Calling a Python function is easy. First, the Python program must somehow "

"pass you the Python function object. You should provide a function (or some "

"other interface) to do this. When this function is called, save a pointer "

"to the Python function object (be careful to :c:func:`Py_INCREF` it!) in a "

"global variable --- or wherever you see fit. For example, the following "

"function might be part of a module definition::"

msgstr ""

msgid ""

"static PyObject *my_callback = NULL;\n"

"\n"

"static PyObject *\n"

"my_set_callback(PyObject *dummy, PyObject *args)\n"

"{\n"

" PyObject *result = NULL;\n"

" PyObject *temp;\n"

"\n"

" if (PyArg_ParseTuple(args, \"O:set_callback\", &temp)) {\n"

" if (!PyCallable_Check(temp)) {\n"

" PyErr_SetString(PyExc_TypeError, \"parameter must be "

"callable\");\n"

" return NULL;\n"

" }\n"

" Py_XINCREF(temp); /* Add a reference to new callback */\n"

" Py_XDECREF(my_callback); /* Dispose of previous callback */\n"

" my_callback = temp; /* Remember new callback */\n"

" /* Boilerplate to return \"None\" */\n"

" Py_INCREF(Py_None);\n"

" result = Py_None;\n"

" }\n"

" return result;\n"

"}"

msgstr ""

msgid ""

"This function must be registered with the interpreter using the :c:macro:"

"`METH_VARARGS` flag; this is described in section :ref:`methodtable`. The :"

"c:func:`PyArg_ParseTuple` function and its arguments are documented in "

"section :ref:`parsetuple`."

msgstr ""

msgid ""

"The macros :c:func:`Py_XINCREF` and :c:func:`Py_XDECREF` increment/decrement "

"the reference count of an object and are safe in the presence of ``NULL`` "

"pointers (but note that *temp* will not be ``NULL`` in this context). More "

"info on them in section :ref:`refcounts`."

msgstr ""

msgid ""

"Later, when it is time to call the function, you call the C function :c:func:"

"`PyObject_CallObject`. This function has two arguments, both pointers to "

"arbitrary Python objects: the Python function, and the argument list. The "

"argument list must always be a tuple object, whose length is the number of "

"arguments. To call the Python function with no arguments, pass in ``NULL``, "

"or an empty tuple; to call it with one argument, pass a singleton tuple. :c:"

"func:`Py_BuildValue` returns a tuple when its format string consists of zero "

"or more format codes between parentheses. For example::"

msgstr ""

msgid ""

"int arg;\n"

"PyObject *arglist;\n"

"PyObject *result;\n"

"...\n"

"arg = 123;\n"

"...\n"

"/* Time to call the callback */\n"

"arglist = Py_BuildValue(\"(i)\", arg);\n"

"result = PyObject_CallObject(my_callback, arglist);\n"

"Py_DECREF(arglist);"

msgstr ""

msgid ""

":c:func:`PyObject_CallObject` returns a Python object pointer: this is the "

"return value of the Python function. :c:func:`PyObject_CallObject` is "

"\"reference-count-neutral\" with respect to its arguments. In the example a "

"new tuple was created to serve as the argument list, which is :c:func:"

"`Py_DECREF`\\ -ed immediately after the :c:func:`PyObject_CallObject` call."

msgstr ""

msgid ""

"The return value of :c:func:`PyObject_CallObject` is \"new\": either it is a "

"brand new object, or it is an existing object whose reference count has been "

"incremented. So, unless you want to save it in a global variable, you "

"should somehow :c:func:`Py_DECREF` the result, even (especially!) if you are "

"not interested in its value."

msgstr ""

msgid ""

"Before you do this, however, it is important to check that the return value "

"isn't ``NULL``. If it is, the Python function terminated by raising an "

"exception. If the C code that called :c:func:`PyObject_CallObject` is called "

"from Python, it should now return an error indication to its Python caller, "

"so the interpreter can print a stack trace, or the calling Python code can "

"handle the exception. If this is not possible or desirable, the exception "

"should be cleared by calling :c:func:`PyErr_Clear`. For example::"

msgstr ""

msgid ""

"if (result == NULL)\n"

" return NULL; /* Pass error back */\n"

"...use result...\n"

"Py_DECREF(result);"

msgstr ""

msgid ""

"Depending on the desired interface to the Python callback function, you may "

"also have to provide an argument list to :c:func:`PyObject_CallObject`. In "

"some cases the argument list is also provided by the Python program, through "

"the same interface that specified the callback function. It can then be "

"saved and used in the same manner as the function object. In other cases, "

"you may have to construct a new tuple to pass as the argument list. The "

"simplest way to do this is to call :c:func:`Py_BuildValue`. For example, if "

"you want to pass an integral event code, you might use the following code::"

msgstr ""

msgid ""

"PyObject *arglist;\n"

"...\n"

"arglist = Py_BuildValue(\"(l)\", eventcode);\n"

"result = PyObject_CallObject(my_callback, arglist);\n"

"Py_DECREF(arglist);\n"

"if (result == NULL)\n"

" return NULL; /* Pass error back */\n"

"/* Here maybe use the result */\n"

"Py_DECREF(result);"

msgstr ""

msgid ""

"Note the placement of ``Py_DECREF(arglist)`` immediately after the call, "

"before the error check! Also note that strictly speaking this code is not "

"complete: :c:func:`Py_BuildValue` may run out of memory, and this should be "

"checked."

msgstr ""

msgid ""

"You may also call a function with keyword arguments by using :c:func:"

"`PyObject_Call`, which supports arguments and keyword arguments. As in the "

"above example, we use :c:func:`Py_BuildValue` to construct the dictionary. ::"

msgstr ""

msgid ""

"PyObject *dict;\n"

"...\n"

"dict = Py_BuildValue(\"{s:i}\", \"name\", val);\n"

"result = PyObject_Call(my_callback, NULL, dict);\n"

"Py_DECREF(dict);\n"

"if (result == NULL)\n"

" return NULL; /* Pass error back */\n"

"/* Here maybe use the result */\n"

"Py_DECREF(result);"

msgstr ""

msgid "Extracting Parameters in Extension Functions"

msgstr "Wydobywanie parametrów w zadaniach rozszerzających"

msgid "The :c:func:`PyArg_ParseTuple` function is declared as follows::"

msgstr ""

msgid "int PyArg_ParseTuple(PyObject *arg, const char *format, ...);"

msgstr ""

msgid ""

"The *arg* argument must be a tuple object containing an argument list passed "

"from Python to a C function. The *format* argument must be a format string, "

"whose syntax is explained in :ref:`arg-parsing` in the Python/C API "

"Reference Manual. The remaining arguments must be addresses of variables "

"whose type is determined by the format string."

msgstr ""

"Parametr *arg* musi być przedmiotem - krotką zawierającym listę parametrów z "

"języka pytonowskiego dla zadania C. Parametr *format* musi być ciągiem "

"formatu, którego składnia jest wyjaśniona w :ref:`arg-parsing` w podręczniku "

"użytkownika API Python/C. Pozostałe parametry muszą być adresami zmiennych "

"których rodzaj jest określony przez ciąg formatujący."

msgid ""

"Note that while :c:func:`PyArg_ParseTuple` checks that the Python arguments "

"have the required types, it cannot check the validity of the addresses of C "

"variables passed to the call: if you make mistakes there, your code will "

"probably crash or at least overwrite random bits in memory. So be careful!"

msgstr ""

msgid ""

"Note that any Python object references which are provided to the caller are "

"*borrowed* references; do not decrement their reference count!"

msgstr ""

"Zauważ, że dowolne odniesienia do przedmiotów języka pytonowskiego, które są "

"dostarczone wołającemu są *pożyczonymi* odniesieniami; nie zmniejszaj liczby "

"tych odniesień."

msgid "Some example calls::"

msgstr "Pewne przykładowe wywołania::"

msgid ""

"int ok;\n"

"int i, j;\n"

"long k, l;\n"

"const char *s;\n"

"Py_ssize_t size;\n"