# SOME DESCRIPTIVE TITLE.

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

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# tomo, 2018

# Shuuji TAKAHASHI <shuuji3@gmail.com>, 2018

# Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2021

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2020-02-09 18:48+0900\n"

"PO-Revision-Date: 2018-06-29 17:45+0000\n"

"Last-Translator: Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2021\n"

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

"ja/)\n"

"Language: ja\n"

"MIME-Version: 1.0\n"

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

"Content-Transfer-Encoding: 8bit\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.org>`_ 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.org>`_ ライブラリの利用"

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

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

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

#: ../../extending/extending.rst:39

msgid "A Simple Example"

msgstr "簡単な例"

#: ../../extending/extending.rst:41

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:52

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:57

msgid "The first line of our file can be::"

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

#: ../../extending/extending.rst:61

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:66

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:70

msgid ""

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

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

"and since they are used extensively by the Python interpreter, ``\"Python."

"h\"`` includes a few standard header files: ``<stdio.h>``, ``<string.h>``, "

"``<errno.h>``, and ``<stdlib.h>``. If the latter header file does not exist "

"on your system, it declares the functions :c:func:`malloc`, :c:func:`free` "

"and :c:func:`realloc` directly."

msgstr ""

":file:`Python.h` で定義されているユーザから可視のシンボルは、全て接頭辞 "

"``Py`` または ``PY`` が付いています。ただし、標準ヘッダファイル内の定義は除き"

"ます。簡単のためと、Python 内で広範に使うことになるという理由から、 "

"``\"Python.h\"`` はいくつかの標準ヘッダファイル: ``<stdio.h>`` 、 ``<string."

"h>`` 、 ``<errno.h>`` 、および ``<stdlib.h>`` をインクルードしています。後者"

"のヘッダファイルがシステム上になければ、 ``\"Python.h\"`` が関数 :c:func:"

"`malloc` 、 :c:func:`free` および :c:func:`realloc` を直接定義します。"

#: ../../extending/extending.rst:78

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:94

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:99

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:102

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:111

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:121

msgid "Intermezzo: Errors and Exceptions"

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

#: ../../extending/extending.rst:123

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 a *NULL* pointer). Exceptions are stored in a static "

"global variable inside the interpreter; if this variable is *NULL* no "

"exception has occurred. A second global variable stores the \"associated "

"value\" of the exception (the second argument to :keyword:`raise`). A third "

"variable contains the stack traceback in case the error originated in Python "

"code. These three variables are the C equivalents of the result in Python "

"of :meth:`sys.exc_info` (see the section on module :mod:`sys` in the Python "

"Library Reference). It is important to know about them to understand how "

"errors are passed around."

msgstr ""

"Python インタプリタ全体を通して、一つの重要な取り決めがあります: それは、関数"

"が処理に失敗した場合、例外状態をセットして、エラーを示す値 (通常は *NULL* ポ"

"インタ) を返さねばならない、ということです。例外はインタプリタ内の静的なグ"

"ローバル変数に保存されます; この値が *NULL* の場合、例外は何も起きていないこ"

"とになります。第二のグローバル変数には、例外の \"付属値 (associated "

"value)\" (:keyword:`raise` 文の第二引数) が入ります。第三の値には、エラーの発"

"生源が Python コード内だった場合にスタックトレースバック (stack traceback) が"

"入ります。これらの三つの変数は、 :meth:`sys.exc_info` の Python での結果と等"

"価な C の変数です (Python ライブラリリファレンスの :mod:`sys` モジュールに関"

"する節を参照してください。) エラーがどのように受け渡されるかを理解するには、"

"これらの変数についてよく知っておくことが重要です。"

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

msgid ""

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

"exceptions."

msgstr ""

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

"す。"

#: ../../extending/extending.rst:136

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:142

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:149

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:155

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 :c:func:`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 :c:func:"

"`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``) を返さねばなりません。しかし、 :"

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

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

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

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

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

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

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

#: ../../extending/extending.rst:165

msgid ""

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

"message by calling another :c:func:`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 ""

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

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

"とはいえ、一般的な規則としては、 :c:func:`PyErr_\\*` を何度も呼び出す必要はな"

"く、ともすればエラーの原因に関する情報を失う結果になりがちです: これにより、"

"ほとんどの操作が様々な理由から失敗するかもしれません)"

#: ../../extending/extending.rst:171

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:177

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:183

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:187

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:191

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_IOError`). 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 ""

"どの例外を返すかの選択は、ユーザに完全にゆだねられます。 :c:data:"

"`PyExc_ZeroDivisionError` のように、全ての組み込みの Python 例外には対応する"

"宣言済みの C オブジェクトがあり、直接利用できます。もちろん、例外の選択は賢く"

"行わねばなりません --- ファイルが開けなかったことを表すのに :c:data:"

"`PyExc_TypeError` を使ったりはしないでください (この場合はおそらく :c:data:"

"`PyExc_IOError` の方にすべきでしょう)。引数リストに問題がある場合には、 :c:"

"func:`PyArg_ParseTuple` はたいてい :c:data:`PyExc_TypeError` を送出します。引"

"数の値が特定の範囲を超えていたり、その他の満たすべき条件を満たさなかった場合"

"には、 :c:data:`PyExc_ValueError` が適切です。"

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

msgid ""

"You can also define a new exception that is unique to your module. For this, "

"you usually declare a static object variable at the beginning of your file::"

msgstr ""

"モジュール固有の新たな例外も定義できます。定義するには、通常はファイルの先頭"

"部分に静的なオブジェクト変数の宣言を行います::"

#: ../../extending/extending.rst:206

msgid ""

"and initialize it in your module's initialization function (:c:func:"

"`PyInit_spam`) with an exception object (leaving out the error checking for "

"now)::"

msgstr ""

"そして、モジュールの初期化関数 (:c:func:`PyInit_spam`) の中で、例外オブジェク"

"トを使って初期化します (ここではエラーチェックを省略しています)::"

#: ../../extending/extending.rst:224

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

"Python レベルでの例外オブジェクトの名前は :exc:`spam.error` になることに注意"

"してください。 :c:func:`PyErr_NewException` 関数は、 :ref:`bltin-exceptions` "

"で述べられている :exc:`Exception` クラスを基底クラスに持つ例外クラスも作成で"

"きます (*NULL* の代わりに他のクラスを渡した場合は別です)。"

#: ../../extending/extending.rst:229

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

":c:data:`SpamError` 変数は、新たに生成された例外クラスへの参照を維持すること"

"にも注意してください; これは意図的な仕様です! 外部のコードが例外オブジェクト"

"をモジュールから除去できるため、モジュールから新たに作成した例外クラスが見え"

"なくなり、 :c:data:`SpamError` がぶら下がりポインタ (dangling pointer) になっ"

"てしまわないようにするために、クラスに対する参照を所有しておかねばなりませ"

"ん。もし :c:data:`SpamError` がぶら下がりポインタになってしまうと、 C コード"

"が例外を送出しようとしたときにコアダンプや意図しない副作用を引き起こすことが"

"あります。"

#: ../../extending/extending.rst:236

msgid ""

"We discuss the use of ``PyMODINIT_FUNC`` as a function return type later in "

"this sample."

msgstr ""

"この例にある、関数の戻り値型に ``PyMODINIT_FUNC`` を使う方法については後で議"

"論します。"

#: ../../extending/extending.rst:239

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

":c:func:`PyErr_SetString` を次のように呼び出すと、拡張モジュールで例外 :exc:"

"`spam.error` を送出することができます::"

#: ../../extending/extending.rst:262

msgid "Back to the Example"

msgstr "例に戻る"

#: ../../extending/extending.rst:264

msgid ""

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

"this statement::"

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

#: ../../extending/extending.rst:270

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

"この実行文は、 :c:func:`PyArg_ParseTuple` がセットする例外によって、引数リス"

"トに何らかのエラーが生じたときに *NULL* (オブジェクトへのポインタを返すタイプ"

"の関数におけるエラー標示値) を返します。エラーでなければ、引数として与えた文"

"字列値はローカルな変数 :c:data:`command` にコピーされています。この操作はポイ"

"ンタ代入であり、ポインタが指している文字列に対して変更が行われるとは想定され"

"ていません (従って、標準 C では、変数 :c:data:`command` は ``const char* "

"command`` として適切に定義せねばなりません)。"

#: ../../extending/extending.rst:278

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:283

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

":func:`spam.system` は :c:data:`sts` を Python オブジェクトとして返さねばなり"

"ません。これには、 :c:func:`PyLong_FromLong` を使います。 ::"

#: ../../extending/extending.rst:288

msgid ""

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

"objects on the heap in Python!)"

msgstr ""

"上の場合では、 :c:func:`Py_BuildValue` は整数オブジェクトを返します。(そう、"

"整数ですら、 Python においてはヒープ上のオブジェクトなのです! )"

#: ../../extending/extending.rst:291

msgid ""

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

"returning :c:type:`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:type:`void` を返す関数) に対応する Python の関"

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

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

"ています)::"

#: ../../extending/extending.rst:299

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:307

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

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

#: ../../extending/extending.rst:309

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

"さて、前に約束したように、 :c:func:`spam_system` を Python プログラムからどう"

"やって呼び出すかをこれから示します。まずは、関数名とアドレスを \"メソッドテー"

"ブル (method table)\" に列挙する必要があります::"

#: ../../extending/extending.rst:320

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:325

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:329

msgid ""

"The :const:`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 ""

"関数にキーワード引数が渡されることになっているのなら、第三フィールドに :"

"const:`METH_KEYWORDS` ビットをセットできます。この場合、C 関数は第三引数に "

"``PyObject *`` を受理するようにせねばなりません。このオブジェクトは、キーワー"

"ド引数の辞書になります。こうした関数で引数を解釈するには、 :c:func:"

"`PyArg_ParseTupleAndKeywords` を使ってください。"

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

msgid ""

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

msgstr ""

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

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

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

"同様に、この構造体は、モジュールの初期化関数内でインタプリタに渡さねばなりま"

"せん。初期化関数はモジュールの名前を *name* としたときに :c:func:"

"`PyInit_name` という名前でなければならず、モジュールファイル内で定義されてい"

"るもののうち、唯一の非 ``static`` 要素でなければなりません::"

#: ../../extending/extending.rst:357

msgid ""

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

"PyMODINIT_FUNC は関数の戻り値を ``PyObject *`` になるように宣言し、プラット"

"フォーム毎に必要とされる、特有のリンク宣言 (linkage declaration) を定義するこ"

"と、さらに C++ の場合には関数を ``extern \"C\"`` に宣言することに注意してくだ"

"さい。"

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

msgid ""

"When the Python program imports module :mod:`spam` for the first time, :c:"

"func:`PyInit_spam` is called. (See below for comments about embedding "

"Python.) It calls :c:func:`PyModule_Create`, which returns a module object, "

"and inserts built-in function objects into the newly created module based "

"upon the table (an array of :c:type:`PyMethodDef` structures) found in the "

"module definition. :c:func:`PyModule_Create` returns a pointer to the module "

"object that it creates. It may abort with a fatal error for certain errors, "

"or return *NULL* if the module could not be initialized satisfactorily. The "

"init function must return the module object to its caller, so that it then "

"gets inserted into ``sys.modules``."

msgstr ""

"Python プログラムが初めて :mod:`spam` モジュールを import するときに、 :c:"

"func:`PyInit_spam` が呼ばれます。 (以下にある Python への埋め込みに関するコメ"

"ントを参照してください。) そこからモジュールオブジェクトを返す :c:func:"

"`PyModule_Create` が呼ばれ、モジュール定義にあるテーブル (:c:type:"

"`PyMethodDef` 構造体の配列) に基いて新たに作られたモジュールに、組み込み関数"

"オブジェクトが挿入されます。 :c:func:`PyModule_Create` は作成したモジュールオ"

"ブジェクトへのポインタを返します。あるエラーによって異常終了するかもしれませ"

"んし、モジュールが問題無く初期化できなかった場合には *NULL* を返すかもしれま"

"せん。 init 関数はモジュールオブジェクトを呼び出し元に返し、それが ``sys."

"modules`` に挿入されるようにしなければなりません。"

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

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

"Python へ埋め込むときに、 :c:data:`PyImport_Inittab` テーブルに存在していて"

"も :c:func:`PyInit_spam` 関数は自動的には呼ばれません。初期化テーブルにモ"

"ジュールを追加するには、 :c:func:`PyImport_AppendInittab` を使ってください。"

"その後にオプションでモジュールを import します::"

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

msgid ""

"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`) can create problems for some "

"extension modules. Extension module authors should exercise caution when "

"initializing internal data structures."

msgstr ""

"単一のプロセス内 (または :c:func:`fork` 後の :c:func:`exec` が介入していない"

"状態) における複数のインタプリタにおいて、 ``sys.modules`` からエントリを除去"

"したり新たなコンパイル済みモジュールを import したりすると、拡張モジュールに"

"よっては問題を生じることがあります。拡張モジュールの作者は、内部データ構造を"

"初期化する際にはよくよく用心すべきです。"

#: ../../extending/extending.rst:414

msgid ""

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

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

"template or simply read as an example."

msgstr ""

"より実質的なモジュール例は、Python ソース配布物に :file:`Modules/xxmodule.c` "

"という名前で入っています。このファイルはテンプレートとしても利用できますし、"

"単に例としても読めます。"

#: ../../extending/extending.rst:420

msgid ""

"Unlike our ``spam`` example, ``xxmodule`` uses *multi-phase initialization* "

"(new in Python 3.5), where a PyModuleDef structure is returned from "

"``PyInit_spam``, and creation of the module is left to the import machinery. "

"For details on multi-phase initialization, see :PEP:`489`."

msgstr ""

"``xmodule`` は ``spam`` と異なり、 *多段階初期化 (multi-phase "

"initialization* (Python 3.5 の新機能) を使っています。 ``PyInit_spam`` が "

"PyModuleDef を返し、モジュールの生成は後に import 機構が行います。多段階初期"

"化についての詳細は :PEP:`489` を参照してください。"

#: ../../extending/extending.rst:429

msgid "Compilation and Linkage"

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

#: ../../extending/extending.rst:431

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:438

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:449

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:455

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:466

msgid "Calling Python Functions from C"

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

#: ../../extending/extending.rst:468

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:476

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:482

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 のコードに対してコールバックを登録し"

"ようとする Python プログラムは、何らかの方法で Python の関数オブジェクトを渡"

"さねばなりません。このために、コールバック登録関数 (またはその他のインタ"

"フェース) を提供せねばなりません。このコールバック登録関数が呼び出された際"

"に、引き渡された Python 関数オブジェクトへのポインタをグローバル変数に --- あ"

"るいは、どこか適切な場所に --- 保存します (関数オブジェクトを :c:func:"

"`Py_INCREF` するようよく注意してください!)。例えば、以下のような関数がモ"

"ジュールの一部になっていることでしょう::"

#: ../../extending/extending.rst:512

msgid ""

"This function must be registered with the interpreter using the :const:"

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

"この関数は :const:`METH_VARARGS` フラグを使ってインタプリタに登録せねばなりま"

"せん; :const:`METH_VARARGS` フラグについては、 :ref:`methodtable` で説明して"

"います。 :c:func:`PyArg_ParseTuple` 関数とその引数については、 :ref:"

"`parsetuple` に記述しています。"

#: ../../extending/extending.rst:517

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

":c:func:`Py_XINCREF` および :c:func:`Py_XDECREF` は、オブジェクトに対する参照"

"カウントをインクリメント/デクリメントするためのマクロで、 *NULL* ポインタが渡"

"されても安全に操作できる形式です (とはいえ、上の流れでは *temp* が *NULL* に"

"なることはありません)。これらのマクロと参照カウントについては、 :ref:"

"`refcounts` で説明しています。"

#: ../../extending/extending.rst:524

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

"その後、コールバック関数を呼び出す時が来たら、C 関数 :c:func:"

"`PyObject_CallObject` を呼び出します。この関数には二つの引数: Python 関数と "

"Python 関数の引数リストがあり、いずれも任意の Python オブジェクトを表すポイン"

"タ型です。引数リストは常にタプルオブジェクトでなければならず、その長さは引数"

"の数になります。Python 関数を引数なしで呼び出すのなら、 NULL か空のタプルを渡"

"します; 単一の引数で関数を呼び出すのなら、単要素 (singleton) のタプルを渡しま"

"す。 :c:func:`Py_BuildValue` の書式文字列中に、ゼロ個または一個以上の書式化"

"コードが入った丸括弧がある場合、この関数はタプルを返します。以下に例を示しま"

"す::"

#: ../../extending/extending.rst:544

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

":c:func:`PyObject_CallObject` は Python オブジェクトへのポインタを返します: "

"これは Python 関数からの戻り値になります。 :c:func:`PyObject_CallObject` は、"

"引数に対して \"参照カウント中立 (reference-count- neutral)\" です。上の例では"

"タプルを生成して引数リストとして提供しており、このタプルは :c:func:"

"`PyObject_CallObject` の呼び出し直後に :c:func:`Py_DECREF` されています。"

#: ../../extending/extending.rst:551

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

":c:func:`PyObject_CallObject` は戻り値として \"新しい\" オブジェクト: 新規に"

"作成されたオブジェクトか、既存のオブジェクトの参照カウントをインクリメントし"

"たものを返します。従って、このオブジェクトをグローバル変数に保存したいのでな"

"いかぎり、たとえこの戻り値に興味がなくても (むしろ、そうであればなおさら!) 何"

"がしかの方法で戻り値オブジェクトを :c:func:`Py_DECREF` しなければなりません。"

#: ../../extending/extending.rst:557

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

"とはいえ、戻り値を :c:func:`Py_DECREF` する前には、値が *NULL* でないかチェッ"

"クしておくことが重要です。もし *NULL* なら、呼び出した Python 関数は例外を送"

"出して終了させられています。 :c:func:`PyObject_CallObject` を呼び出している"

"コード自体もまた Python から呼び出されているのであれば、今度は C コードが自分"

"を呼び出している Python コードにエラー標示値を返さねばなりません。それによ"

"り、インタプリタはスタックトレースを出力したり、例外を処理するための Python "

"コードを呼び出したりできます。例外の送出が不可能だったり、したくないのな"

"ら、 :c:func:`PyErr_Clear` を呼んで例外を消去しておかねばなりません。例えば以"

"下のようにします::"

#: ../../extending/extending.rst:570

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

"Python コールバック関数をどんなインタフェースにしたいかによっては、引数リスト"

"を :c:func:`PyObject_CallObject` に与えなければならない場合もあります。ある"

"ケースでは、コールバック関数を指定したのと同じインタフェースを介して、引数リ"

"ストも渡されているかもしれません。また別のケースでは、新しいタプルを構築して"

"引数リストを渡さねばならないかもしれません。この場合最も簡単なのは :c:func:"

"`Py_BuildValue` を呼ぶやり方です。例えば、整数のイベントコードを渡したけれ"

"ば、以下のようなコードを使うことになるでしょう::"

#: ../../extending/extending.rst:589

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

"``Py_DECREF(arglist)`` が呼び出しの直後、エラーチェックよりも前に置かれている"

"ことに注意してください! また、厳密に言えば、このコードは完全ではありません: :"

"c:func:`Py_BuildValue` はメモリ不足におちいるかもしれず、チェックしておくべき"

"です。"

#: ../../extending/extending.rst:593

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

"通常の引数とキーワード引数をサポートする :c:func:`PyObject_Call` を使って、"

"キーワード引数を伴う関数呼び出しをすることができます。上の例と同じように、 :"

"c:func:`Py_BuildValue` を作って辞書を作ります。 ::"

#: ../../extending/extending.rst:611

msgid "Extracting Parameters in Extension Functions"

msgstr "拡張モジュール関数でのパラメタ展開"

#: ../../extending/extending.rst:615

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

msgstr ":c:func:`PyArg_ParseTuple` 関数は以下のように宣言されています::"

#: ../../extending/extending.rst:619

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

"引数 *arg* は C 関数から Python に渡される引数リストが入ったタプルオブジェク"

"トでなければなりません。 *format* 引数は書式文字列で、 Python/C API リファレ"

"ンスマニュアルの :ref:`arg-parsing` で解説されている書法に従わねばなりませ"

"ん。残りの引数は、それぞれの変数のアドレスで、書式化文字列から決まる型になっ"

"ていなければなりません。"

#: ../../extending/extending.rst:625

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

":c:func:`PyArg_ParseTuple` は Python 側から与えられた引数が必要な型になってい"

"るか調べるのに対し、 :c:func:`PyArg_ParseTuple` は呼び出しの際に渡された C 変"

"数のアドレスが有効な値を持つか調べられないことに注意してください: ここで間違"

"いを犯すと、コードがクラッシュするかもしれませんし、少なくともでたらめなビッ"

"トをメモリに上書きしてしまいます。慎重に!"

#: ../../extending/extending.rst:630

msgid ""

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

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

msgstr ""

"呼び出し側に提供されるオブジェクトへの参照はすべて *借用* 参照 (borrowed "

"reference) になります; これらのオブジェクトの参照カウントをデクリメントしては"

"なりません!"

#: ../../extending/extending.rst:633

msgid "Some example calls::"

msgstr "以下にいくつかの呼び出し例を示します::"

#: ../../extending/extending.rst:703

msgid "Keyword Parameters for Extension Functions"

msgstr "拡張モジュール関数のキーワードパラメタ"

#: ../../extending/extending.rst:707

msgid ""

"The :c:func:`PyArg_ParseTupleAndKeywords` function is declared as follows::"

msgstr ""