# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

# qqfunc, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

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

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

"Last-Translator: qqfunc, 2025\n"

"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"

"ja/)\n"

"MIME-Version: 1.0\n"

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

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

"Language: ja\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../extending/extending.rst:8

msgid "Extending Python with C or C++"

msgstr "C や C++ による Python の拡張"

#: ../../extending/extending.rst:10

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

"C プログラムの書き方を知っているなら、Python に新たな組み込みモジュールを追加"

"するのはきわめて簡単です。この新たなモジュール、拡張モジュール (:dfn:"

"`extension module`) を使うと、Python が直接行えない二つのこと: 新しい組み込み"

"オブジェクトの実装、そして全ての C ライブラリ関数とシステムコールに対する呼び"

"出し、ができるようになります。"

#: ../../extending/extending.rst:15

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

"拡張モジュールをサポートするため、Python API (Application Programmer's "

"Interface) では一連の関数、マクロおよび変数を提供していて、Python ランタイム"

"システムのほとんどの側面へのアクセス手段を提供しています。 Python API は、"

"ヘッダ ``\"Python.h\"`` をインクルードして C ソースに取り込みます。"

#: ../../extending/extending.rst:20

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

"拡張モジュールのコンパイル方法は、モジュールの用途やシステムの設定方法に依存"

"します。詳細は後の章で説明します。"

#: ../../extending/extending.rst:25

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

"C 拡張のインターフェイスは CPython に固有のものであり、これによる拡張モジュー"

"ルはほかの Python 実装では動作しません。多くの場合、C 拡張を書くことを避けて"

"ほかの Python 実装のために移植性を確保することは可能です。たとえば、あなたが"

"したいことが C ライブラリの関数やシステムコールを呼び出すことである場合、 :"

"mod:`ctypes` あるいは `cffi <https://cffi.readthedocs.io/>`_ ライブラリの利用"

"を検討すべきです。これらのモジュールは C コードとインターフェイスし、C 拡張を"

"書いてコンパイルするのに較べて Python 実装間のより高い移植性をもった Python "

"コードを書かせてくれます。"

#: ../../extending/extending.rst:40

msgid "A Simple Example"

msgstr "簡単な例"

#: ../../extending/extending.rst:42

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

"``spam`` (Monty Python ファンの好物ですね) という名の拡張モジュールを作成する"

"ことにして、C ライブラリ関数 :c:func:`system` に対する Python インターフェイ"

"スを作成したいとします。 [#]_ この関数は null で終端されたキャラクタ文字列を"

"引数にとり、整数を返します。この関数を以下のようにして Python から呼び出せる"

"ようにしたいとします。"

#: ../../extending/extending.rst:48

msgid ""

">>> import spam\n"

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

msgstr ""

#: ../../extending/extending.rst:53

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

"まずは :file:`spammodule.c` を作成するところから始めます。 (伝統として、 "

"``spam`` という名前のモジュールを作成する場合、モジュールの実装が入った C "

"ファイルを :file:`spammodule.c` と呼ぶことになっています; ``spammify`` のよう"

"に長すぎるモジュール名の場合には、単に :file:`spammify.c` にもできます。)"

#: ../../extending/extending.rst:58

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

msgstr "このファイルの最初の 2 行は以下のようにします::"

#: ../../extending/extending.rst:60 ../../extending/extending.rst:706

msgid ""

"#define PY_SSIZE_T_CLEAN\n"

"#include <Python.h>"

msgstr ""

"#define PY_SSIZE_T_CLEAN\n"

"#include <Python.h>"

#: ../../extending/extending.rst:63

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

"これで、Python API を取り込みます (必要なら、モジュールの用途に関する説明や、"

"著作権表示を追加します)。"

#: ../../extending/extending.rst:68

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

"Python は、システムによっては標準ヘッダの定義に影響するようなプリプロセッサ定"

"義を行っているので、 :file:`Python.h` をいずれの標準ヘッダよりも前にインク"

"ルード *せねばなりません* 。"

#: ../../extending/extending.rst:72

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

"``#define PY_SSIZE_T_CLEAN`` は、いくつかの API では ``int`` の代わりに "

"``Py_ssize_t`` が使われるべきであることを示すために使われていました。これは "

"Python 3.13 以降では不要となりましたが、後方互換性のために維持されています。"

"このマクロの説明は :ref:`arg-parsing-string-and-buffers` にあります。"

#: ../../extending/extending.rst:77

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

#: ../../extending/extending.rst:82

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

#: ../../extending/extending.rst:87

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

msgstr ""

#: ../../extending/extending.rst:88

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

msgstr ""

#: ../../extending/extending.rst:89

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

msgstr ""

#: ../../extending/extending.rst:90

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

msgstr ""

#: ../../extending/extending.rst:91

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

msgstr ""

#: ../../extending/extending.rst:92

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

msgstr ""

#: ../../extending/extending.rst:93

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

msgstr ""

#: ../../extending/extending.rst:94

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

msgstr ""

#: ../../extending/extending.rst:96

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

#: ../../extending/extending.rst:99

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

msgstr ""

#: ../../extending/extending.rst:100

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

msgstr ""

#: ../../extending/extending.rst:102

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

#: ../../extending/extending.rst:105

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

msgstr ""

#: ../../extending/extending.rst:106

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

msgstr ""

#: ../../extending/extending.rst:107

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

msgstr ""

#: ../../extending/extending.rst:108

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

msgstr ""

#: ../../extending/extending.rst:110

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

"次にファイルに追加する内容は、Python 式 ``spam.system(string)`` を評価する際"

"に呼び出されることになる C 関数です (この関数を最終的にどのように呼び出すか"

"は、後ですぐわかります)::"

#: ../../extending/extending.rst:114

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

#: ../../extending/extending.rst:126

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

"ここでは、Python の引数リスト (例えば、単一の式 ``\"ls -l\"``) から C 関数に"

"渡す引数にそのまま変換しています。 C 関数は常に二つの引数を持ち、便宜的に "

"*self* および *args* と呼ばれます。"

#: ../../extending/extending.rst:131

msgid ""

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

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

msgstr ""

"*self* 引数には、モジュールレベルの関数であればモジュールが、メソッドにはオブ"

"ジェクトインスタンスが渡されます。"

#: ../../extending/extending.rst:134

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

"*args* 引数は、引数の入った Python タプルオブジェクトへのポインタになります。"

"タプル内の各要素は、呼び出しの際の引数リストにおける各引数に対応します。引数"

"は Python オブジェクトです --- C 関数で引数を使って何かを行うには、オブジェク"

"トから C の値に変換せねばなりません。Python API の関数 :c:func:"

"`PyArg_ParseTuple` は引数の型をチェックし、C の値に変換します。 :c:func:"

"`PyArg_ParseTuple` はテンプレート文字列を使って、引数オブジェクトの型と、変換"

"された値を入れる C 変数の型を判別します。これについては後で詳しく説明します。"

#: ../../extending/extending.rst:143

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

":c:func:`PyArg_ParseTuple` は、全ての引数が正しい型を持っていて、アドレス渡し"

"された各変数に各引数要素を保存したときに真 (非ゼロ) を返します。この関数は不"

"正な引数リストを渡すと偽 (ゼロ) を返します。後者の場合、関数は適切な例外を送"

"出するので、呼び出し側は (例にもあるように) すぐに ``NULL`` を返すようにして"

"ください。"

#: ../../extending/extending.rst:153

msgid "Intermezzo: Errors and Exceptions"

msgstr "幕間小話: エラーと例外"

#: ../../extending/extending.rst:155

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

#: ../../extending/extending.rst:164

msgid ""

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

"exceptions."

msgstr ""

"Python API では、様々な型の例外をセットするための関数をいくつか定義していま"

"す。"

#: ../../extending/extending.rst:166

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

"もっともよく用いられるのは :c:func:`PyErr_SetString` です。引数は例外オブジェ"

"クトと C 文字列です。例外オブジェクトは通常、 :c:data:"

"`PyExc_ZeroDivisionError` のような定義済みのオブジェクトです。 C 文字列はエ"

"ラーの原因を示し、Python 文字列オブジェクトに変換されて例外の \"付属値\" に保"

"存されます。"

#: ../../extending/extending.rst:172

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

"もう一つ有用な関数として :c:func:`PyErr_SetFromErrno` があります。この関数は"

"引数に例外だけをとり、付属値はグローバル変数 :c:data:`errno` から構築します。"

"もっとも汎用的な関数は :c:func:`PyErr_SetObject` で、二つのオブジェクト、例外"

"と付属値を引数にとります。これら関数に渡すオブジェクトには :c:func:"

"`Py_INCREF` を使う必要はありません。"

#: ../../extending/extending.rst:179

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

"例外がセットされているかどうかは、 :c:func:`PyErr_Occurred` を使って非破壊的"

"に調べられます。この関数は現在の例外オブジェクトを返します。例外が発生してい"

"ない場合には ``NULL`` を返します。通常は、関数の戻り値からエラーが発生したか"

"を判別できるはずなので、 :c:func:`PyErr_Occurred` を呼び出す必要はありませ"

"ん。"

#: ../../extending/extending.rst:185

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

"関数 *g* を呼び出す *f* が、前者の関数の呼び出しに失敗したことを検出すると、 "

"*f* 自体はエラー値 (大抵は ``NULL`` や ``-1``) を返さねばなりません。しか"

"し、 ``PyErr_*`` 関数群のいずれかを呼び出す必要は *ありません* --- なぜな"

"ら、 *g* がすでに呼び出しているからです。次いで *f* を呼び出したコードもエ"

"ラーを示す値を *自らを呼び出したコード* に返すことになりますが、同様に "

"``PyErr_*`` は *呼び出しません* 。以下同様に続きます --- エラーの最も詳しい原"

"因は、最初にエラーを検出した関数がすでに報告しているからです。エラーが "

"Python インタプリタのメインループに到達すると、現在実行中の Python コードは一"

"時停止し、 Python プログラマが指定した例外ハンドラを探し出そうとします。"

#: ../../extending/extending.rst:195

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

"(モジュールが ``PyErr_*`` 関数をもう一度呼び出して、より詳細なエラーメッセー"

"ジを提供するような状況があります。このような状況ではそうすべきです。とはい"

"え、一般的な規則としては、この関数を何度も呼び出す必要はなく、ともすればエ"

"ラーの原因に関する情報を失う結果になりがちです: これにより、ほとんどの操作が"

"様々な理由から失敗するかもしれません)"

#: ../../extending/extending.rst:201

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

"ある関数呼び出しでの処理の失敗によってセットされた例外を無視するには、 :c:"

"func:`PyErr_Clear` を呼び出して例外状態を明示的に消去しなくてはなりません。エ"

"ラーをインタプリタには渡したくなく、自前で (何か他の作業を行ったり、何も起こ"

"らなかったかのように見せかけるような) エラー処理を完全に行う場合にのみ、 :c:"

"func:`PyErr_Clear` を呼び出すようにすべきです。"

#: ../../extending/extending.rst:207

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

":c:func:`malloc` の呼び出し失敗は、常に例外にしなくてはなりません --- :c:"

"func:`malloc` (または :c:func:`realloc`) を直接呼び出しているコードは、 :c:"

"func:`PyErr_NoMemory` を呼び出して、失敗を示す値を返さねばなりません。オブ"

"ジェクトを生成する全ての関数 (例えば :c:func:`PyLong_FromLong`) は :c:func:"

"`PyErr_NoMemory` の呼び出しを済ませてしまうので、この規則が関係するのは直接 :"

"c:func:`malloc` を呼び出すコードだけです。"

#: ../../extending/extending.rst:213

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

"また、 :c:func:`PyArg_ParseTuple` という重要な例外を除いて、整数の状態コード"

"を返す関数はたいてい、Unix のシステムコールと同じく、処理が成功した際にはゼロ"

"または正の値を返し、失敗した場合には ``-1`` を返します。"

#: ../../extending/extending.rst:217

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

"最後に、エラー標示値を返す際に、(エラーが発生するまでに既に生成してしまったオ"

"ブジェクトに対して :c:func:`Py_XDECREF` や :c:func:`Py_DECREF` を呼び出して) "

"ごみ処理を注意深く行ってください!"

#: ../../extending/extending.rst:221

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

#: ../../extending/extending.rst:231

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

#: ../../extending/extending.rst:235

msgid "static PyObject *SpamError = NULL;"

msgstr ""

#: ../../extending/extending.rst:237

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

#: ../../extending/extending.rst:240

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

msgstr ""

#: ../../extending/extending.rst:242

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

#: ../../extending/extending.rst:245

msgid ""

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

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

msgstr ""

#: ../../extending/extending.rst:248

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

#: ../../extending/extending.rst:284

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

#: ../../extending/extending.rst:289

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

#: ../../extending/extending.rst:296

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

#: ../../extending/extending.rst:301

msgid ""

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

"later in this sample."

msgstr ""

#: ../../extending/extending.rst:304

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

#: ../../extending/extending.rst:307

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

#: ../../extending/extending.rst:327

msgid "Back to the Example"

msgstr "例に戻る"

#: ../../extending/extending.rst:329

msgid ""

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

"this statement::"

msgstr "先ほどの関数の例に戻ると、今度は以下の実行文を理解できるはずです::"

#: ../../extending/extending.rst:332

msgid ""

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

" return NULL;"

msgstr ""

#: ../../extending/extending.rst:335

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

#: ../../extending/extending.rst:343

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

"次の文では、 :c:func:`PyArg_ParseTuple` で得た文字列を渡して Unix 関数 :c:"

"func:`system` を呼び出しています::"

#: ../../extending/extending.rst:346

msgid "sts = system(command);"

msgstr ""

#: ../../extending/extending.rst:348

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

#: ../../extending/extending.rst:351

msgid "return PyLong_FromLong(sts);"

msgstr ""

#: ../../extending/extending.rst:353

msgid ""

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

"objects on the heap in Python!)"

msgstr ""

"上の場合では、整数オブジェクトを返します。(そう、整数ですら、 Python において"

"はヒープ上のオブジェクトなのです! )"

#: ../../extending/extending.rst:356

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

"何ら有用な値を返さない関数 (:c:expr:`void` を返す関数) に対応する Python の関"

"数は ``None`` を返さねばなりません。関数に ``None`` を返させるには、以下のよ"

"うな慣用句を使います (この慣用句は :c:macro:`Py_RETURN_NONE` マクロに実装され"

"ています)::"

#: ../../extending/extending.rst:361

msgid ""

"Py_INCREF(Py_None);\n"

"return Py_None;"

msgstr ""

#: ../../extending/extending.rst:364

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

":c:data:`Py_None` は特殊な Pyhton オブジェクトである ``None`` に対応する C で"

"の名前です。これまで見てきたようにほとんどのコンテキストで \"エラー\" を意味"

"する ``NULL`` ポインタとは違い、 ``None`` は純粋な Python のオブジェクトで"

"す。"

#: ../../extending/extending.rst:372

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

msgstr "モジュールのメソッドテーブルと初期化関数"

#: ../../extending/extending.rst:374

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

#: ../../extending/extending.rst:377

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

#: ../../extending/extending.rst:385

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

"リスト要素の三つ目のエントリ (``METH_VARARGS``) に注意してください。このエン"

"トリは、C 関数が使う呼び出し規約をインタプリタに教えるためのフラグです。通常"

"この値は ``METH_VARARGS`` か ``METH_VARARGS | METH_KEYWORDS`` のはずです; "

"``0`` は旧式の :c:func:`PyArg_ParseTuple` の変化形が使われることを意味しま"

"す。"

#: ../../extending/extending.rst:390

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

"``METH_VARARGS`` だけを使う場合、C 関数は、Python レベルでの引数が :c:func:"

"`PyArg_ParseTuple` が受理できるタプルの形式で渡されるものと想定しなければなり"

"ません; この関数についての詳細は下で説明します。"

#: ../../extending/extending.rst:394

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

#: ../../extending/extending.rst:400

msgid ""

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

msgstr ""

"メソッドテーブルはモジュール定義の構造体から参照されていなければなりません::"

#: ../../extending/extending.rst:402

msgid ""

"static struct PyModuleDef spam_module = {\n"

" ...\n"

" .m_methods = spam_methods,\n"

" ...\n"

"};"

msgstr ""

#: ../../extending/extending.rst:408

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

#: ../../extending/extending.rst:413

msgid ""

"PyMODINIT_FUNC\n"

"PyInit_spam(void)\n"

"{\n"

" return PyModuleDef_Init(&spam_module);\n"

"}"

msgstr ""

#: ../../extending/extending.rst:419

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

#: ../../extending/extending.rst:423

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

#: ../../extending/extending.rst:428

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

#: ../../extending/extending.rst:433

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

#: ../../extending/extending.rst:483

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

#: ../../extending/extending.rst:492

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

#: ../../extending/extending.rst:500

msgid "Compilation and Linkage"

msgstr "コンパイルとリンク"

#: ../../extending/extending.rst:502

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

"新しい拡張モジュールを使えるようになるまで、まだ二つの作業: コンパイルと、"

"Python システムへのリンク、が残っています。動的読み込み (dynamic loading) を"

"使っているのなら、作業の詳細は自分のシステムが使っている動的読み込みの形式に"

"よって変わるかもしれません; 詳しくは、拡張モジュールのビルドに関する章 (:ref:"

"`building` 章) や、Windows におけるビルドに関係する追加情報の章 (:ref:"

"`building-on-windows` 章) を参照してください。"

#: ../../extending/extending.rst:509

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

"動的読み込みを使えなかったり、モジュールを常時 Python インタプリタの一部にし"

"ておきたい場合には、インタプリタのビルド設定を変更して再ビルドしなければなら"

"なくなるでしょう。Unixでは、幸運なことにこの作業はとても単純です: 単に自作の"

"モジュールファイル (例えば :file:`spammodule.c`) を展開したソース配布物の :"

"file:`Modules/` ディレクトリに置き、 :file:`Modules/Setup.local` に自分の"

"ファイルを説明する以下の一行:"

#: ../../extending/extending.rst:516

msgid "spam spammodule.o"

msgstr ""

#: ../../extending/extending.rst:520

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

"を追加して、トップレベルのディレクトリで :program:`make` を実行して、インタプ"

"リタを再ビルドするだけです。 :file:`Modules/` サブディレクトリでも :program:"

"`make` を実行できますが、前もって ':program:`make` Makefile' を実行して :"

"file:`Makefile` を再ビルドしておかなければならりません。(この作業は :file:"

"`Setup` ファイルを変更するたびに必要です。)"

#: ../../extending/extending.rst:526

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

"モジュールが別のライブラリとリンクされている必要がある場合、ライブラリも設定"

"ファイルに列挙できます。例えば以下のようにします。"

#: ../../extending/extending.rst:529

msgid "spam spammodule.o -lX11"

msgstr ""

#: ../../extending/extending.rst:537

msgid "Calling Python Functions from C"

msgstr "C から Python 関数を呼び出す"

#: ../../extending/extending.rst:539

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

"これまでは、Python からの C 関数の呼び出しに重点を置いて述べてきました。とこ"

"ろでこの逆: C からの Python 関数の呼び出しもまた有用です。とりわけ、いわゆる "

"\"コールバック\" 関数をサポートするようなライブラリを作成する際にはこの機能が"

"便利です。ある C インターフェースがコールバックを利用している場合、同等の機能"

"を提供する Python コードでは、しばしば Python プログラマにコールバック機構を"

"提供する必要があります; このとき実装では、 C で書かれたコールバック関数から "

"Python で書かれたコールパック関数を呼び出すようにする必要があるでしょう。もち"

"ろん、他の用途も考えられます。"

#: ../../extending/extending.rst:547

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

"幸運なことに、Python インタプリタは簡単に再帰呼び出しでき、 Python 関数を呼び"

"出すための標準インターフェースもあります。 (Python パーザを特定の入力文字を"

"使って呼び出す方法について詳説するつもりはありません --- この方法に興味がある"

"なら、 Python ソースコードの :file:`Modules/main.c` にある、コマンドラインオ"

"プション :option:`-c` の実装を見てください)"

#: ../../extending/extending.rst:553

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

"Python 関数の呼び出しは簡単です。まず、C のコードに対してコールバックを登録し"