pytho****@googl*****
pytho****@googl*****
2011年 3月 31日 (木) 10:57:33 JST
Revision: ed2c4dd596ea Author: Naoki INADA <inada****@klab*****> Date: Wed Mar 30 18:55:11 2011 Log: c-api の old C markup を一括置換. http://code.google.com/p/python-doc-ja/source/detail?r=ed2c4dd596ea Modified: /c-api/abstract.rst /c-api/allocation.rst /c-api/arg.rst /c-api/bool.rst /c-api/buffer.rst /c-api/bytearray.rst /c-api/cobject.rst /c-api/complex.rst /c-api/concrete.rst /c-api/conversion.rst /c-api/datetime.rst /c-api/dict.rst /c-api/exceptions.rst /c-api/file.rst /c-api/float.rst /c-api/function.rst /c-api/gcsupport.rst /c-api/gen.rst /c-api/import.rst /c-api/init.rst /c-api/int.rst /c-api/intro.rst /c-api/iterator.rst /c-api/list.rst /c-api/long.rst /c-api/mapping.rst /c-api/marshal.rst /c-api/memory.rst /c-api/method.rst /c-api/module.rst /c-api/none.rst /c-api/number.rst /c-api/objbuffer.rst /c-api/object.rst /c-api/refcounting.rst /c-api/reflection.rst /c-api/sequence.rst /c-api/set.rst /c-api/slice.rst /c-api/string.rst /c-api/structures.rst /c-api/sys.rst /c-api/tuple.rst /c-api/type.rst /c-api/typeobj.rst /c-api/unicode.rst /c-api/veryhigh.rst /c-api/weakref.rst ======================================= --- /c-api/abstract.rst Sun Nov 21 04:56:32 2010 +++ /c-api/abstract.rst Wed Mar 30 18:55:11 2011 @@ -12,7 +12,7 @@ オブジェクトに対する操作を行ないます。 関数を適用対象でないオブジェクトに対して使った場合、 Python の例外が送出さ れることになります。 -これらの関数は、 :cfunc:`PyList_New` で作成された後に ``NULL`` 以外の値を +これらの関数は、 :c:func:`PyList_New` で作成された後に ``NULL`` 以外の値を 設定されていないリストのような、適切に初期化されていないオブジェクトに対し て使うことはできません。 ======================================= --- /c-api/allocation.rst Wed Dec 1 08:48:08 2010 +++ /c-api/allocation.rst Wed Mar 30 18:55:11 2011 @@ -6,41 +6,41 @@ ====================================== -.. cfunction:: PyObject* _PyObject_New(PyTypeObject *type) +.. c:function:: PyObject* _PyObject_New(PyTypeObject *type) -.. cfunction:: PyVarObject* _PyObject_NewVar(PyTypeObject *type, Py_ssize_t size) +.. c:function:: PyVarObject* _PyObject_NewVar(PyTypeObject *type, Py_ssize_t size) .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 -.. cfunction:: void _PyObject_Del(PyObject *op) +.. c:function:: void _PyObject_Del(PyObject *op) -.. cfunction:: PyObject* PyObject_Init(PyObject *op, PyTypeObject *type) +.. c:function:: PyObject* PyObject_Init(PyObject *op, PyTypeObject *type) 新たにメモリ確保されたオブジェクト *op* に対し、型と初期状態での参照 (initial reference) を初期化します。 初期化されたオブジェクトを返します。 *type* からそのオブジェクトが循環参 照ガベージ検出の機能を有する場合、検出機構が監視対象とする オブジェクトのセットに追加されます。オブジェクトの他のフィールドには影響 を及ぼしません。 -.. cfunction:: PyVarObject* PyObject_InitVar(PyVarObject *op, PyTypeObject *type, Py_ssize_t size) - - :cfunc:`PyObject_Init` の全ての処理を行い、可変サイズオブジェクトの場合 には長さ情報も初期化します。 +.. c:function:: PyVarObject* PyObject_InitVar(PyVarObject *op, PyTypeObject *type, Py_ssize_t size) + + :c:func:`PyObject_Init` の全ての処理を行い、可変サイズオブジェクトの場合 には長さ情報も初期化します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 -.. cfunction:: TYPE* PyObject_New(TYPE, PyTypeObject *type) +.. c:function:: TYPE* PyObject_New(TYPE, PyTypeObject *type) C 構造体型 *TYPE* と Python 型オブジェクト *type* を使って新たな Python オブジェクトをメモリ確保します。 Python オブジェクトヘッダで定義されていないフィールドは初期化されません; オブジ ェクトの参照カウントは 1 になります。メモリ確保のサイズは型オブジェクトの :attr:`tp_basicsize` で決定します。 -.. cfunction:: TYPE* PyObject_NewVar(TYPE, PyTypeObject *type, Py_ssize_t size) +.. c:function:: TYPE* PyObject_NewVar(TYPE, PyTypeObject *type, Py_ssize_t size) C 構造体型 *TYPE* と Python 型オブジェクト *type* を使って新たな Python オブジェクトをメモリ確保します。 Python オブジェクトヘッダで定義されていないフィールドは初期化されません。確保さ れたメモリは、 *TYPE* 構造体に加え、vartype の @@ -49,18 +49,18 @@ 対するアロケーション操作を一つにして埋め込むと、アロケーション回数が減 り、メモリ管理の処理効率が向上します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 -.. cfunction:: void PyObject_Del(PyObject *op) - - :cfunc:`PyObject_New` や :cfunc:`PyObject_NewVar` で +.. c:function:: void PyObject_Del(PyObject *op) + + :c:func:`PyObject_New` や :c:func:`PyObject_NewVar` で 確保されたメモリを解放します。この関数は、通常オブジェクトの型に指定され ている :attr:`tp_dealloc` ハンドラ内で呼び出します。 この関数を呼び出した後では、オブジェクトのメモリ領域はもはや有効な Python オブジェクトを表現してはいないので、オブジェクトのフィールド に対してアクセスしてはなりません。 -.. cfunction:: PyObject* Py_InitModule(char *name, PyMethodDef *methods) +.. c:function:: PyObject* Py_InitModule(char *name, PyMethodDef *methods) *name* と関数のテーブルに基づいて新たなモジュールオブジェクトを生成し、 生成されたモジュールオブジェクトを返します。 @@ -68,7 +68,7 @@ 以前のバージョンの Python では、 *methods* 引数の値として *NULL* をサ ポートしていませんでした. -.. cfunction:: PyObject* Py_InitModule3(char *name, PyMethodDef *methods, char *doc) +.. c:function:: PyObject* Py_InitModule3(char *name, PyMethodDef *methods, char *doc) *name* と関数のテーブルに基づいて新たなモジュールオブジェクトを生成し、 生成されたモジュールオブジェクトを返します。 *doc* が *NULL* でない場合、モジュールの docstring として使われます。 @@ -77,7 +77,7 @@ 以前のバージョンの Python では、 *methods* 引数の値として *NULL* をサ ポートしていませんでした. -.. cfunction:: PyObject* Py_InitModule4(char *name, PyMethodDef *methods, char *doc, PyObject *self, int apiver) +.. c:function:: PyObject* Py_InitModule4(char *name, PyMethodDef *methods, char *doc, PyObject *self, int apiver) *name* と関数のテーブルに基づいて新たなモジュールオブジェクトを生成し、 生成されたモジュールオブジェクトを返します。 *doc* が *NULL* でない場合、モジュールの docstring として使われます。 *self* が *NULL* でない場合、モジュール内の各関数 @@ -87,13 +87,13 @@ .. note:: - この関数のほとんどの用途は、代わりに :cfunc:`Py_InitModule3` を使える はずです; 本当にこの関数を使いたいときにだけ利用してください + この関数のほとんどの用途は、代わりに :c:func:`Py_InitModule3` を使え るはずです; 本当にこの関数を使いたいときにだけ利用してください .. versionchanged:: 2.3 以前のバージョンの Python では、 *methods* 引数の値として *NULL* をサ ポートしていませんでした. -.. cvar:: PyObject _Py_NoneStruct +.. c:var:: PyObject _Py_NoneStruct Python からは ``None`` に見えるオブジェクトです。この値へのアクセスは、 このオブジェクトへのポインタを評価する ``Py_None`` マクロを使わねばなりません。 ======================================= --- /c-api/arg.rst Mon Nov 29 06:26:25 2010 +++ /c-api/arg.rst Wed Mar 30 18:55:11 2011 @@ -8,8 +8,8 @@ これらの関数は独自の拡張モジュール用の関数やメソッドを作成する際に便利で す。 詳しい情報や用例は :ref:`extending-index` にあります。 -最初に説明する 3 つの関数、 :cfunc:`PyArg_ParseTuple`, -:cfunc:`PyArg_ParseTupleAndKeywords`,および :cfunc:`PyArg_Parse` はいずれも +最初に説明する 3 つの関数、 :c:func:`PyArg_ParseTuple`, +:c:func:`PyArg_ParseTupleAndKeywords`,および :c:func:`PyArg_Parse` はいずれ も *書式化文字列 (format string)* を使います。 書式化文字列は、関数が受け取るはずの引数に関する情報を伝えるのに用いられま す。 いずれの関数における書式化文字列も、同じ書式を使っています。 @@ -28,15 +28,15 @@ いてはなりません; もし埋め込まれていれば :exc:`TypeError` 例外を送出しま す。Unicode オブジェクトはデフォルトエンコーディングを使って C 文字列に変換されます。変換に失敗すると :exc:`UnicodeError` を送出しま す。 -``s#`` (文字列型、Unicode 型または任意の読み出しバッファ互換型) [const char \*, int (または :ctype:`Py_ssize_t`, 下記参照)] +``s#`` (文字列型、Unicode 型または任意の読み出しバッファ互換型) [const char \*, int (または :c:type:`Py_ssize_t`, 下記参照)] これは ``s`` の変化形で、値を二つの変数に記録します。一つ目の変数はキャ ラクタ文字列へのポインタで、二つ目はその長さです。 この書式化単位の場合には、Python 文字列に null バイトが埋め込まれていて もかまいません。 Unicode オブジェクトの場合、デフォルト エンコーディングでの変換が可能ならば、変換したオブジェクトから文字列への ポインタを返します。その他の読み出しバッファ互換オブジェクトは 生の内部データ表現への参照を返します。 Python 2.5 から、長さの引数の型を、 :file:`Python.h` を include する前に - :cmacro:`PY_SSIZE_T_CLEAN` マクロ を定義することで制御できるようになりま した。 - もしこのマクロが定義されていた場合、長さは int ではな く :ctype:`Py_ssize_t` + :c:macro:`PY_SSIZE_T_CLEAN` マクロ を定義することで制御できるようになり ました。 + もしこのマクロが定義されていた場合、長さは int ではな く :c:type:`Py_ssize_t` になります。 ``s*`` (文字列、Unicode、または任意のバッファー互換オブジェクト) [Py_buffer] @@ -61,25 +61,25 @@ ``u`` (Unicode 型) [Py_UNICODE \*] Python の Unicode オブジェクトを、NUL で終端された 16 ビットの Unicode (UTF-16) データに変換します。 ``s`` - と同様に、 Unicode データバッファ用に記憶領域を提供する必要はありませ ん; :ctype:`Py_UNICODE` + と同様に、 Unicode データバッファ用に記憶領域を提供する必要はありませ ん; :c:type:`Py_UNICODE` 型ポインタ変数のアドレスを渡すと、すでに存在している Unicode データへの ポインタをその変数に記録します。 ``u#`` (Unicode 型) [Py_UNICODE \*, int] これは ``u`` の変化形で、値を二つの変数に記録します。一つ目の変数は Unicode データバッファへのポインタで、二つ目はその長さです。非 - Unicode のオブジェクトの場合、読み出しバッファのポインタ を :ctype:`Py_UNICODE` 型シーケンスへのポインタと解釈して扱います。 + Unicode のオブジェクトの場合、読み出しバッファのポインタ を :c:type:`Py_UNICODE` 型シーケンスへのポインタと解釈して扱います。 ``es`` (文字列型、Unicode 型または任意の読み出しバッファ互換型)[const char \*encoding, char \*\*buffer] これは ``s`` の変化形で、Unicode オブジェクトや Unicode に変換可能なオブ ジェクトをキャラクタ型バッファにエンコードするために 用いられます。NUL バイトが埋め込まれていない文字列でのみ動作します。 - この書式化単位には二つの引数が必要です。一つ目は入力にのみ用いられ、 NUL で終端されたエンコード名文字列を指す :ctype:`const char\*` - 型でなければなりません。指定したエンコード名を Python が理解できない場合 には例外を送出します。第二の引数は :ctype:`char\*\*` + この書式化単位には二つの引数が必要です。一つ目は入力にのみ用いられ、 NUL で終端されたエンコード名文字列を指す :c:type:`const char\*` + 型でなければなりません。指定したエンコード名を Python が理解できない場合 には例外を送出します。第二の引数は :c:type:`char\*\*` でなければなりません; この引数が参照しているポインタの値は、引数に指定し たテキストの内容が入ったバッファへのポインタになります。 テキストは最初の引数に指定したエンコード方式でエンコードされます。 - :cfunc:`PyArg_ParseTuple` を使うと、必要なサイズのバッファを確保し、その バッファにエンコード後のデータをコピーして、 + :c:func:`PyArg_ParseTuple` を使うと、必要なサイズのバッファを確保し、そ のバッファにエンコード後のデータをコピーして、 *\*buffer* がこの新たに確保された記憶領域を指すように変更します。呼び出 し側には、確保されたバッファを使い終わった後に - :cfunc:`PyMem_Free` で解放する責任があります。 + :c:func:`PyMem_Free` で解放する責任があります。 ``et`` (文字列型、Unicode 型または文字列バッファ互換型) [const char \*encoding, char \*\*buffer] ``es`` と同じです。ただし、8 ビット幅の文字列オブジェクトをエンコードし 直さずに渡します。その代わり、実装では文字列オブジェクトが @@ -89,9 +89,9 @@ ``s#`` の変化形で、Unicode オブジェクトや Unicode に変換可能なオブジェク トをキャラクタ型バッファにエンコードするために 用いられます。 ``es`` 書式化単位と違って、この変化形はバイトが埋め込まれ ていてもかまいません。 - この書式化単位には三つの引数が必要です。一つ目は入力にのみ用いられ、 NUL で終端されたエンコード名文字列を指す :ctype:`const char\*` + この書式化単位には三つの引数が必要です。一つ目は入力にのみ用いられ、 NUL で終端されたエンコード名文字列を指す :c:type:`const char\*` 型か *NULL* でなければなりません。 *NULL* の場合にはデフォルトエンコーデ ィングを使います。指定したエンコード名を Python が理解できない - 場合には例外を送出します。第二の引数は :ctype:`char\*\*` でなければなり ません; この引数が参照しているポインタの値は、引数に指定した + 場合には例外を送出します。第二の引数は :c:type:`char\*\*` でなければなり ません; この引数が参照しているポインタの値は、引数に指定した テキストの内容が入ったバッファへのポインタになります。テキストは最初の引 数に指定したエンコード方式でエンコードされます。 第三の引数は整数へのポインタでなければなりません; ポインタが参照している 整数の値は出力バッファ内のバイト数にセットされます。 @@ -99,11 +99,11 @@ *\*buffer * が* NULL* ポインタを指している場合、関数は必要なサイズのバッ ファを確保し、そのバッファにエンコード後の データをコピーして、*\*buffer* がこの新たに確保された記憶領域を指すよう に変更します。呼び出し側には、確保されたバッファを使い終わった後に - :cfunc:`PyMem_Free` で解放する責任があります。 - - *\*buffer* が非 *NULL* のポインタ (すでにメモリ確保済みのバッファ) を指 している場合、 :cfunc:`PyArg_ParseTuple` + :c:func:`PyMem_Free` で解放する責任があります。 + + *\*buffer* が非 *NULL* のポインタ (すでにメモリ確保済みのバッファ) を指 している場合、 :c:func:`PyArg_ParseTuple` はこのメモリ位置をバッファとして用い、*\*buffer_length* - の初期値をバッファサイズとして用います。 :cfunc:`PyArg_ParseTuple` は次 にエンコード済みのデータをバッファにコピーして、NUL で終端 + の初期値をバッファサイズとして用います。 :c:func:`PyArg_ParseTuple` は 次にエンコード済みのデータをバッファにコピーして、NUL で終端 します。バッファの大きさが足りなければ :exc:`ValueError` がセットされま す。 どちらの場合も、 *\*buffer_length* は終端の NUL バイトを含まないエンコー ド済みデータの長さにセットされます。 @@ -113,64 +113,64 @@ パラメタに渡したエンコードを使っているものと仮定します。 ``b`` (整数型) [unsigned char] - Python の非負の整数型を、 C の :ctype:`unsigned char` 型の小さな符号無し 整数に変換します。 + Python の非負の整数型を、 C の :c:type:`unsigned char` 型の小さな符号無 し整数に変換します。 ``B`` (整数型) [unsigned char] - Python の整数型を、オーバフローチェックを行わずに、 C の :ctype:`unsigned char` 型の小さな整数に変換します。 + Python の整数型を、オーバフローチェックを行わずに、 C の :c:type:`unsigned char` 型の小さな整数に変換します。 .. versionadded:: 2.3 ``h`` (整数型) [short int] - Python の整数型を、 C の :ctype:`short int` 型に変換します。 + Python の整数型を、 C の :c:type:`short int` 型に変換します。 ``H`` (整数型) [unsigned short int] - Python の整数型を、オーバフローチェックを行わずに、 C の :ctype:`unsigned short int` 型に変換します。 + Python の整数型を、オーバフローチェックを行わずに、 C の :c:type:`unsigned short int` 型に変換します。 .. versionadded:: 2.3 ``i`` (整数型) [int] - Python の整数型を、 C の :ctype:`int` 型に変換します。 + Python の整数型を、 C の :c:type:`int` 型に変換します。 ``I`` (整数型) [unsigned int] - Python の整数型を、オーバフローチェックを行わずに、 C の :ctype:`unsigned int` 型に変換します。 + Python の整数型を、オーバフローチェックを行わずに、 C の :c:type:`unsigned int` 型に変換します。 .. versionadded:: 2.3 ``l`` (整数型) [long int] - Python の整数型を、 C の :ctype:`long int` 型に変換します。 + Python の整数型を、 C の :c:type:`long int` 型に変換します。 ``k`` (整数型) [unsigned long] - Python の整数型もしくは長整数型を、オーバフローチェックを行わずに、 C の :ctype:`unsigned long int` 型に変換します。 + Python の整数型もしくは長整数型を、オーバフローチェックを行わずに、 C の :c:type:`unsigned long int` 型に変換します。 .. versionadded:: 2.3 ``L`` (整数型) [PY_LONG_LONG] - Python の整数型を、 C の :ctype:`long long` 型に変換します。この書式化単 位は、 :ctype:`long long` 型 (または - Windows の :ctype:`_int64` 型) がサポートされているプラットフォームでの み利用できます。 + Python の整数型を、 C の :c:type:`long long` 型に変換します。この書式化 単位は、 :c:type:`long long` 型 (または + Windows の :c:type:`_int64` 型) がサポートされているプラットフォームで のみ利用できます。 ``K`` (整数型) [unsigned PY_LONG_LONG] - Python の整数型もしくは長整数型を、オーバフローチェックを行わずに、 C の :ctype:`unsigned long long` 型に変換します。 - この書式化単位は、 :ctype:`unsigned long long` 型 (または Windows の :ctype:`unsigned _int64` + Python の整数型もしくは長整数型を、オーバフローチェックを行わずに、 C の :c:type:`unsigned long long` 型に変換します。 + この書式化単位は、 :c:type:`unsigned long long` 型 (または Windows の :c:type:`unsigned _int64` 型) がサポートされているプラットフォームでのみ利用できます。 .. versionadded:: 2.3 ``n`` (integer) [Py_ssize_t] - Python の整数型もしくは長整数型をCの :ctype:`Py_ssize_t` 型に変換しま す。 + Python の整数型もしくは長整数型をCの :c:type:`Py_ssize_t` 型に変換しま す。 .. versionadded:: 2.5 ``c`` (長さ 1 の文字列型) [char] - 長さ 1 の文字列として表現されている Python キャラクタを C の :ctype:`char` 型に変換します。 + 長さ 1 の文字列として表現されている Python キャラクタを C の :c:type:`char` 型に変換します。 ``f`` (浮動小数点型) [float] - Python の浮動小数点型を、 C の :ctype:`float` 型に変換します。 + Python の浮動小数点型を、 C の :c:type:`float` 型に変換します。 ``d`` (浮動小数点型) [double] - Python の浮動小数点型を、 C の :ctype:`double` 型に変換します。 + Python の浮動小数点型を、 C の :c:type:`double` 型に変換します。 ``D`` (複素数型) [Py_complex] - Python の複素数型を、 C の :ctype:`Py_complex` 構造体に変換します。 + Python の複素数型を、 C の :c:type:`Py_complex` 構造体に変換します。 ``O`` (オブジェクト) [PyObject \*] Python オブジェクトを (一切変換を行わずに) C の Python オブジェクト型ポ インタに保存します。これにより、C @@ -178,31 +178,31 @@ ``O!`` (オブジェクト) [*typeobject*, PyObject \*] Python オブジェクトを C の Python オブジェクト型ポインタに保存します。 ``O`` に似ていますが、二つの C の引数をとります: - 一つ目の引数は Python の型オブジェクトへのアドレスで、二つ目の引数はオブ ジェクトへのポインタが保存されている (:ctype:`PyObject\*` + 一つ目の引数は Python の型オブジェクトへのアドレスで、二つ目の引数はオブ ジェクトへのポインタが保存されている (:c:type:`PyObject\*` の) C の変数へのアドレスです。Python オブジェクトが指定した型ではない場 合、 :exc:`TypeError` を送出します。 ``O&`` (オブジェクト) [*converter*, *anything*] Python オブジェクトを *converter* 関数を介して C の変数に変換します。二 つの引数をとります: 一つ目は関数で、二つ目は (任意の型の) - C 変数へのアドレスを :ctype:`void \*` 型に変換したものです。 *converter* は以下のようにして呼び出されます: + C 変数へのアドレスを :c:type:`void \*` 型に変換したものです。 *converter* は以下のようにして呼び出されます: *status* ``=``*converter *``(``* object*, *address* ``);`` - ここで *object* は変換対象の Python オブジェクトで、 *address* は :cfunc:`PyArg_Parse\*` に渡した - :ctype:`void\*` 型の引数です。戻り値 *status* は変換に成功した際に ``1``,失敗した場合には ``0`` + ここで *object* は変換対象の Python オブジェクトで、 *address* は :c:func:`PyArg_Parse\*` に渡した + :c:type:`void\*` 型の引数です。戻り値 *status* は変換に成功した際に ``1``,失敗した場合には ``0`` になります。変換に失敗した場合、 *converter* 関数は *address* の内容を変 更せずに例外を送出しなくてはなりません。 ``S`` (文字列型) [PyStringObject \*] ``O`` に似ていますが、Python オブジェクトは文字列オブジェクトでなければ なりません。 - オブジェクトが文字列オブジェクトでない場合には :exc:`TypeError` を送出し ます。 C 変数は :ctype:`PyObject\*` + オブジェクトが文字列オブジェクトでない場合には :exc:`TypeError` を送出し ます。 C 変数は :c:type:`PyObject\*` で宣言しておいてもかまいません。 ``U`` (Unicode 型) [PyUnicodeObject \*] ``O`` に似ていますが、Python オブジェクトは Unicode オブジェクトでなけれ ばなりません。オブジェクトが Unicode - オブジェクトでない場合には :exc:`TypeError` を送出します。 C 変数 は :ctype:`PyObject\*` で宣言しておいてもかまいません。 + オブジェクトでない場合には :exc:`TypeError` を送出します。 C 変数 は :c:type:`PyObject\*` で宣言しておいてもかまいません。 ``t#`` (読み出し専用キャラクタバッファ) [char \*, int] - ``s#`` に似ていますが、読み出し専用バッファインタフェースを実装している 任意のオブジェクトを受理します。 :ctype:`char\*` - 変数はバッファの最初のバイトを指すようにセットされ、 :ctype:`int` はバッ ファの長さにセットされます。 + ``s#`` に似ていますが、読み出し専用バッファインタフェースを実装している 任意のオブジェクトを受理します。 :c:type:`char\*` + 変数はバッファの最初のバイトを指すようにセットされ、 :c:type:`int` はバ ッファの長さにセットされます。 単一セグメントからなるバッファオブジェクトだけを受理します; それ以外の場 合には :exc:`TypeError` を送出します。 ``w`` (読み書き可能なキャラクタバッファ) [char \*] @@ -211,8 +211,8 @@ 単一セグメントからなるバッファオブジェクトだけを受理します; それ以外の場 合には :exc:`TypeError` を送出します。 ``w#`` (読み書き可能なキャラクタバッファ) [char \*, Py_ssize_t] - ``s#`` に似ていますが、読み書き可能なバッファインタフェースを実装してい る任意のオブジェクトを受理します。 :ctype:`char\*` - 変数はバッファの最初のバイトを指すようにセットさ れ、 :ctype:`Py_ssize_t` はバッファの長さにセットされます。 + ``s#`` に似ていますが、読み書き可能なバッファインタフェースを実装してい る任意のオブジェクトを受理します。 :c:type:`char\*` + 変数はバッファの最初のバイトを指すようにセットさ れ、 :c:type:`Py_ssize_t` はバッファの長さにセットされます。 単一セグメントからなるバッファオブジェクトだけを受理します; それ以外の場 合には :exc:`TypeError` を送出します。 ``w*`` (読み書きできるバイト列バッファ) [Py_buffer] @@ -238,12 +238,12 @@ ``|`` Python 引数リスト中で、この文字以降の引数がオプションであることを示しま す。オプションの引数に対応する C の変数はデフォルトの値で初期化して - おかねばなりません --- オプションの引数が省略された場 合、 :cfunc:`PyArg_ParseTuple` は対応する C 変数の内容に + おかねばなりません --- オプションの引数が省略された場 合、 :c:func:`PyArg_ParseTuple` は対応する C 変数の内容に 手を加えません。 ``:`` この文字があると、書式化単位の記述はそこで終わります; コロン以降の文字列 は、エラーメッセージにおける関数名 - (:cfunc:`PyArg_ParseTuple` が送出する例外の "付属値 (associated value)") として使われます。 + (:c:func:`PyArg_ParseTuple` が送出する例外の "付属値 (associated value)") として使われます。 ``;`` この文字があると、書式化単位の記述はそこで終わります; セミコロン以降の文 字列は、デフォルトエラーメッセージを *置き換える* @@ -257,8 +257,8 @@ その場合、対応する書式化単位の指定する形式に従うようにせねばなりません。 変換を正しく行うためには、 *arg* オブジェクトは書式化文字に一致しなければな らず、かつ書式化文字列内の書式化単位に全て値が入るようにせねばなりません。 -成功すると、 :cfunc:`PyArg_Parse\*` 関数は真を返します。それ以外の場合には 偽を返し、適切な例外を送出します。 -書式化単位のどれかの変換失敗により :cfunc:`PyArg_Parse\*` が失敗した場合、 +成功すると、 :c:func:`PyArg_Parse\*` 関数は真を返します。それ以外の場合には 偽を返し、適切な例外を送出します。 +書式化単位のどれかの変換失敗により :c:func:`PyArg_Parse\*` が失敗した場合、 失敗した書式化単位に対応するアドレスとそれ以降のアドレスの内容は変更されま せん。 @@ -270,7 +270,7 @@ .. cfunction:: int PyArg_VaParse(PyObject *args, const char *format, va_list vargs) - :cfunc:`PyArg_ParseTuple` と同じですが、可変長の引数ではなく *va_list* を引数にとります。 + :c:func:`PyArg_ParseTuple` と同じですが、可変長の引数ではなく *va_list* を引数にとります。 .. cfunction:: int PyArg_ParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, char *keywords[], ...) @@ -281,7 +281,7 @@ .. cfunction:: int PyArg_VaParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, char *keywords[], va_list vargs) - :cfunc:`PyArg_ParseTupleAndKeywords` と同じですが、可変長の引数ではなく *va_list* を引数にとります。 + :c:func:`PyArg_ParseTupleAndKeywords` と同じですが、可変長の引数ではな く *va_list* を引数にとります。 .. cfunction:: int PyArg_Parse(PyObject *args, const char *format, ...) @@ -297,7 +297,7 @@ パラメータ取得を簡単にした形式で、引数の型を指定する書式化文字列を使いま せん。パラメタの取得にこの手法を使う関数は、関数宣言テーブル、またはメソッド 宣言テーブル内で :const:`METH_VARARGS` として宣言しなくてはなりません。 実引数の入ったタプルは *args* に渡します; このタプルは本当のタプルでなくてはなりません。タプルの長さは少なくとも *min* で、 *max* を超えてはなりません; *min* と *max* - が等しくてもかまいません。補助引数を関数に渡さなくてはならず、各補助引数 は :ctype:`PyObject\*` 変数へのポインタでなくてはなりません; + が等しくてもかまいません。補助引数を関数に渡さなくてはならず、各補助引数 は :c:type:`PyObject\*` 変数へのポインタでなくてはなりません; これらの補助引数には、 *args* の値が入ります; 値の参照は借りた参照です。 オプションのパラメタに対応する変数のうち、 *args* に指定していない ものには値が入りません; 呼び出し側はそれらの値を初期化しておかねばなりま せん。この関数は成功すると真を返し、 *args* がタプルでない場合や 間違った数の要素が入っている場合に偽を返します; 何らかの失敗が起きた場合 には例外をセットします。 @@ -317,7 +317,7 @@ return result; } - この例における :cfunc:`PyArg_UnpackTuple` 呼び出し は、 :cfunc:`PyArg_ParseTuple` を使った以下の呼び出し:: + この例における :c:func:`PyArg_UnpackTuple` 呼び出し は、 :c:func:`PyArg_ParseTuple` を使った以下の呼び出し:: PyArg_ParseTuple(args, "O|O:ref", &object, &callback) @@ -326,22 +326,22 @@ .. versionadded:: 2.2 .. versionchanged:: 2.5 - この関数は *min* と *max* に :ctype:`int` を利用していました。 + この関数は *min* と *max* に :c:type:`int` を利用していました。 この変更により、64bitシステムを正しくサポートするためには修正が必要に なるでしょう。 .. cfunction:: PyObject* Py_BuildValue(const char *format, ...) - :cfunc:`PyArg_Parse\*` ファミリの関数が受け取るのと似た形式の書式化文字 列および値列に基づいて、新たな値を生成します。 + :c:func:`PyArg_Parse\*` ファミリの関数が受け取るのと似た形式の書式化文字 列および値列に基づいて、新たな値を生成します。 生成した値を返します。エラーの場合には *NULL* を返します; *NULL* を返す 場合、例外を送出するでしょう。 - :cfunc:`Py_BuildValue` は常にタプルを生成するとは限りません。この関数が タプルを生成するのは、書式化文字列に二つ以上の書式化単位 + :c:func:`Py_BuildValue` は常にタプルを生成するとは限りません。この関数が タプルを生成するのは、書式化文字列に二つ以上の書式化単位 が入っているときだけです。書式化文字列が空の場合、 ``None`` を返しま す; 書式化単位が厳密に一つだけ入っている場合、 書式化単位で指定されている何らかのオブジェクト単体を返します。サイズがゼ ロや 1 のタプルを返すように強制するには、丸括弧で囲われた書式化文字列を使い ます。 書式化単位 ``s`` や ``s#`` の場合のように、オブジェクトを構築する際に データを供給するためにメモリバッファをパラメタとして渡す - 場合には、指定したデータはコピーされます。 :cfunc:`Py_BuildValue` が生成 したオブジェクトは、呼び出し側が提供したバッファを決して参照 - しません。別の言い方をすれば、 :cfunc:`malloc` を呼び出してメモリを確保 し、それを :cfunc:`Py_BuildValue` - に渡した場合、コード内で :cfunc:`Py_BuildValue` が返った後 で :cfunc:`free` を呼び出す責任があるということです。 + 場合には、指定したデータはコピーされます。 :c:func:`Py_BuildValue` が生 成したオブジェクトは、呼び出し側が提供したバッファを決して参照 + しません。別の言い方をすれば、 :c:func:`malloc` を呼び出してメモリを確保 し、それを :c:func:`Py_BuildValue` + に渡した場合、コード内で :c:func:`Py_BuildValue` が返った後 で :c:func:`free` を呼び出す責任があるということです。 以下の説明では、引用符のついた形式は書式化単位です; (丸)括弧で囲った部分 は書式化単位が返す Python のオブジェクト型です; [角] 括弧は関数に渡す値の C 変数型です。 @@ -370,60 +370,60 @@ Unicode バッファポインタが *NULL* の場合、長さは無視され ``None`` に なります。 ``i`` (整数型) [int] - 通常の C の :ctype:`int` を Python の整数オブジェクトに変換します。 + 通常の C の :c:type:`int` を Python の整数オブジェクトに変換します。 ``b`` (整数型) [char] - ``i`` と同じです。通常のC の :ctype:`char` を Python の整数オブジェク トに変換します。 + ``i`` と同じです。通常のC の :c:type:`char` を Python の整数オブジェ クトに変換します。 ``h`` (整数型) [short int] - 通常のC の :ctype:`short int` を Python の整数オブジェクトに変換しま す。 + 通常のC の :c:type:`short int` を Python の整数オブジェクトに変換しま す。 ``l`` (整数型) [long int] - C の :ctype:`long int` を Python の整数オブジェクトに変換します。 + C の :c:type:`long int` を Python の整数オブジェクトに変換します。 ``B`` (integer) [unsigned char] - C の :ctype:`unsigned char` を Python の整数オブジェクトに変換しま す。 + C の :c:type:`unsigned char` を Python の整数オブジェクトに変換しま す。 ``H`` (integer) [unsigned short int] - C の :ctype:`unsigned short int` を Python の整数オブジェクトに変換し ます。 + C の :c:type:`unsigned short int` を Python の整数オブジェクトに変換 します。 ``I`` (integer/long) [unsigned int] - C の :ctype:`unsigned int` を Python の整数オブジェクト、あるいは、値 が ``sys.maxint`` + C の :c:type:`unsigned int` を Python の整数オブジェクト、あるいは、 値が ``sys.maxint`` より大きければ長整数オブジェクトに変換します。 ``k`` (integer/long) [unsigned long] - C の :ctype:`unsigned long` を Python の整数オブジェクト、あるいは、 値が ``sys.maxint`` + C の :c:type:`unsigned long` を Python の整数オブジェクト、あるいは、 値が ``sys.maxint`` より大きければ長整数オブジェクトに変換します。 ``L`` (long) [PY_LONG_LONG] - C の :ctype:`long long` を Python の長整数オブジェクトに変換しま す。 :ctype:`long long` + C の :c:type:`long long` を Python の長整数オブジェクトに変換しま す。 :c:type:`long long` をサポートしているプラットフォームでのみ利用可能です。 ``K`` (long) [unsigned PY_LONG_LONG] - C の :ctype:`unsigned long long` を Python の長整数オブジェクトに変換 します。 :ctype:`long long` + C の :c:type:`unsigned long long` を Python の長整数オブジェクトに変 換します。 :c:type:`long long` をサポートしているプラットフォームでのみ利用可能です。 ``n`` (int) [Py_ssize_t] - C の :ctype:`unsigned long` を Python の整数オブジェクト、あるいは長 整数オブジェクトに変換します。 + C の :c:type:`unsigned long` を Python の整数オブジェクト、あるいは長 整数オブジェクトに変換します。 .. versionadded:: 2.5 ``c`` (string of length 1) [char] - 文字を表す通常の C の :ctype:`int` を、長さ 1 の Python の文字列オブ ジェクトに変換します。 + 文字を表す通常の C の :c:type:`int` を、長さ 1 の Python の文字列オブ ジェクトに変換します。 ``d`` (浮動小数点型) [double] - C の :ctype:`double` を Python の浮動小数点数に変換します。 + C の :c:type:`double` を Python の浮動小数点数に変換します。 ``f`` (浮動小数点型) [float] ``d`` と同じです。 ``D`` (複素数型) [Py_complex \*] - C の :ctype:`Py_complex` 構造体を Python の複素数に変換します。 + C の :c:type:`Py_complex` 構造体を Python の複素数に変換します。 ``O`` (オブジェクト) [PyObject \*] Python オブジェクトを手を加えずに渡します (ただし、参照カウントは 1 インクリメントします)。渡したオブジェクトが *NULL* ポインタ の場合、この引数を生成するのに使った何らかの呼び出しがエラーになった のが原因であると仮定して、例外をセットします。従ってこのとき - :cfunc:`Py_BuildValue` は *NULL* を返しますが :cfunc:`Py_BuildValue` 自体は例外を送出しません。 + :c:func:`Py_BuildValue` は *NULL* を返します が :c:func:`Py_BuildValue` 自体は例外を送出しません。 例外をまだ送出していなければ :exc:`SystemError` をセットします。 ``S`` (オブジェクト) [PyObject \*] @@ -435,7 +435,7 @@ ``O&`` (オブジェクト) [*converter*, *anything*] *anything* を *converter* 関数を介して Python オブジェクトに変換しま す。この関数は *anything* - (:ctype:`void \*` と互換の型でなければなりません) を引数にして呼び出 され、"新たな" オブジェクトを返すか、失敗した場合には + (:c:type:`void \*` と互換の型でなければなりません) を引数にして呼び出 され、"新たな" オブジェクトを返すか、失敗した場合には *NULL* を返すようにしなければなりません。 ``(items)`` (タプル型) [*matching-items*] @@ -451,5 +451,5 @@ .. cfunction:: PyObject* Py_VaBuildValue(const char *format, va_list vargs) - :cfunc:`Py_BuildValue` と同じですが、可変長引数の代わりに va_list を受け 取ります。 - + :c:func:`Py_BuildValue` と同じですが、可変長引数の代わりに va_list を受 け取ります。 + ======================================= --- /c-api/bool.rst Sun Nov 21 06:00:19 2010 +++ /c-api/bool.rst Wed Mar 30 18:55:11 2011 @@ -14,7 +14,7 @@ .. cfunction:: int PyBool_Check(PyObject *o) - *o* が :cdata:`PyBool_Type` の場合に真を返します。 + *o* が :c:data:`PyBool_Type` の場合に真を返します。 .. versionadded:: 2.3 ======================================= --- /c-api/buffer.rst Sat Feb 19 23:09:58 2011 +++ /c-api/buffer.rst Wed Mar 30 18:55:11 2011 @@ -23,7 +23,7 @@ バッファインタフェースの使い手の一例として、ファイルオブジェクト の :meth:`write` メソッドがあります。バッファインタフェースを 介してバイト列を公開しているオブジェクトは全て、ファイルへの書き出しができ ます。オブジェクトのバッファインタフェースを操作し、 -対象となるオブジェクトからデータを返させる :cfunc:`PyArg_ParseTuple` には 数多くのデータ書式化コードがあります。 +対象となるオブジェクトからデータを返させる :c:func:`PyArg_ParseTuple` には 数多くのデータ書式化コードがあります。 バージョン 1.6 から、Python は Python レベルのバッファオブジェクトと、 C 言語レベルのバッファAPIを提供しており、任意のビルトイン型やユーザー定義型 は @@ -66,24 +66,24 @@ .. cmember:: int ndim - メモリが多次元配列を表している時の次元数。 0 の場 合、 :cdata:`strides` - と :cdata:`suboffsets` は *NULL* でなければなりません。 + メモリが多次元配列を表している時の次元数。 0 の場 合、 :c:data:`strides` + と :c:data:`suboffsets` は *NULL* でなければなりません。 .. cmember:: Py_ssize_t *shape - メモリが多次元配列を表しているとき、その形を示す長さ :cdata:`ndim` の - :ctype:`Py_ssize_t` の配列。 - ``((*shape)[0] * ... * (*shape)[ndims-1])*itemsize`` は :cdata:`len` + メモリが多次元配列を表しているとき、その形を示す長さ :c:data:`ndim` の + :c:type:`Py_ssize_t` の配列。 + ``((*shape)[0] * ... * (*shape)[ndims-1])*itemsize`` は :c:data:`len` と等しくなければならないことに気をつけてください。 .. cmember:: Py_ssize_t *strides - 各次元で次の要素を得るためにスキップするバイト数を示す、長 さ :cdata:`ndim` - の :ctype:`Py_ssize_t` の配列。 + 各次元で次の要素を得るためにスキップするバイト数を示す、長 さ :c:data:`ndim` + の :c:type:`Py_ssize_t` の配列。 .. cmember:: Py_ssize_t *suboffsets - 長さ :cdata:`ndim` の、 :ctype:`Py_ssize_t` の配列。 + 長さ :c:data:`ndim` の、 :c:type:`Py_ssize_t` の配列。 suboffset の各数値が0以上であるとき、その次元に格納されているのはポイ ンタで、 suboffset の値はそのポインタの参照を解決するときに何バイトのオフセッ トを足すかを 示しています。 @@ -110,7 +110,7 @@ .. cmember:: Py_ssize_t itemsize これは共有メモリ上の各要素のbyte単位のサイズを格納する変数です。 - これは :cfunc:`PyBuffer_SizeFromFormat` を使って計算できる値なので + これは :c:func:`PyBuffer_SizeFromFormat` を使って計算できる値なので 技術的には不要なのですが、バッファを提供する側はフォーマット文字列を 解析しなくてもこの情報を知っているでしょうし、バッファを受け取る側に とっては正しく解釈するのに必要な情報です。なので、要素サイズを格納す る @@ -137,7 +137,7 @@ .. cfunction:: int PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags) - *obj* を :ctype:`Py_buffer` *view* へエクスポートします。 + *obj* を :c:type:`Py_buffer` *view* へエクスポートします。 これらの引数は *NULL* であってはなりません。 *flag* 引数は呼び出し側がどんなバッファを扱おうとしているのか、 バッファ提供側がどんなバッファを返すことが許されているのかを示す、 @@ -150,7 +150,7 @@ 何かが不可能であることを伝えるためにエラーを発生させる必要があるかも しれません。 その場合のエラーは、もしその問題を実際に引き起こしているのが別のエ ラーだったとしても、 :exc:`BufferError` でなければなりません。 - バッファ提供側は flag の情報を使って :cdata:`Py_buffer` 構造体のどの フィールドへの + バッファ提供側は flag の情報を使って :c:data:`Py_buffer` 構造体のどの フィールドへの 非デフォルト値の設定を省略したり、要求されたシンプルな view を提供で きない場合は エラーを発生させたりすることができます。 @@ -161,7 +161,7 @@ +-----------------------------------+--------------------------------------------------------------+ | Flag | 説 明 | +===================================+==============================================================+ - | :cmacro:`PyBUF_SIMPLE` | これはデフォルトの flag の状態 です。 | + | :c:macro:`PyBUF_SIMPLE` | これはデフォルトの flag の状態 です。 | | | 結果のバッファは書き込み可能か もしれませんし、不可能かも | | | しれません。データのフォーマッ トは unsigned byte とします。 | | | これは "スタンドアロン" のフラ グ定数です。他の定数と '|' | @@ -170,10 +170,10 @@ | | 場合に、エラーを発生させるかも しれません。 | | | | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_WRITABLE` | 結果のバッファは書込み可能でな ければなりません。 | + | :c:macro:`PyBUF_WRITABLE` | 結果のバッファは書込み可能でな ければなりません。 | | | 書き込み不可能な場合はエラーを 発生させます。 | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_STRIDES` | この値は :cmacro:`PyBUF_ND` を 含みます。 | + | :c:macro:`PyBUF_STRIDES` | この値は :c:macro:`PyBUF_ND` を 含みます。 | | | バッファは strides 情報を提供し なければなりません。 | | | (言い換えると、 strides は NULL ではなりません。) | | | このフラグは、呼び出し元が、要 素間に隙間のある不連続な | @@ -183,50 +183,50 @@ | | suboffset が必要な場合)はエラー を発生させます。 | | | | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_ND` | バッファは shape 情報を提供しな ければなりません。 | + | :c:macro:`PyBUF_ND` | バッファは shape 情報を提供しな ければなりません。 | | | メモリは C スタイルの並び (最後 の次元が一番高速) だと仮定 | | | されます。提供側はこの種類の連 続バッファを提供できない場合は | | | エラーを発生させます。このフラ グが指定されていな場合は shape | | | は *NULL* になりま す。 | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_C_CONTIGUOUS` | これらのフラグは、返されるバッ ファの並びを指定します。 | - | :cmacro:`PyBUF_F_CONTIGUOUS` | それぞれ、C並び(最後の次元が一 番高速)、Fortran並び(最初の | - | :cmacro:`PyBUF_ANY_CONTIGUOUS` | 次元が一番高速), そのどちらで も、を意味します。 | - | | これらのフラグ は :cmacro:`PyBUF_STRIDES` を含んでおり、 | + | :c:macro:`PyBUF_C_CONTIGUOUS` | これらのフラグは、返されるバッ ファの並びを指定します。 | + | :c:macro:`PyBUF_F_CONTIGUOUS` | それぞれ、C並び(最後の次元が一 番高速)、Fortran並び(最初の | + | :c:macro:`PyBUF_ANY_CONTIGUOUS` | 次元が一番高速), そのどちらで も、を意味します。 | + | | これらのフラグ は :c:macro:`PyBUF_STRIDES` を含んでおり、 | | | strides 情報が正しく格納されて いることを保証します。 | | | | | | | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_INDIRECT` | このフラグは、返されるバッファ が suboffsets 情報を含んで | + | :c:macro:`PyBUF_INDIRECT` | このフラグは、返されるバッファ が suboffsets 情報を含んで | | | いることを示します。 (suboffsets が必要無いときは NULL でも | | | かまいません。) このフラグは、 バッファ利用側が suboffsets | | | を使って参照されている間接配列 を扱えるときに利用されます。 | - | | このフラグ は :cmacro:`PyBUF_STRIDES` を含みます。 | + | | このフラグ は :c:macro:`PyBUF_STRIDES` を含みます。 | | | | | | | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_FORMAT` | 返されるバッファは正しい format 情報を持っていなければ | + | :c:macro:`PyBUF_FORMAT` | 返されるバッファは正しい format 情報を持っていなければ | | | なりません。このフラグは、バッ ファ利用側が実際に格納されて | | | いるデータの '種類' をチェック するときに利用します。 | | | バッファ提供側は、要求された場 合は常にこの情報を提供できる | | | べきです。 format が明示的に要 求されていない場合は format は | | | *NULL* (``'B'``, unsigned byte を意味する)であるべきです。 | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_STRIDED` | ``(PyBUF_STRIDES | PyBUF_WRITABLE)`` と同じ | + | :c:macro:`PyBUF_STRIDED` | ``(PyBUF_STRIDES | PyBUF_WRITABLE)`` と同じ | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_STRIDED_RO` | ``(PyBUF_STRIDES)`` と同 じ | + | :c:macro:`PyBUF_STRIDED_RO` | ``(PyBUF_STRIDES)`` と同 じ | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_RECORDS` | ``(PyBUF_STRIDES | PyBUF_FORMAT | PyBUF_WRITABLE)`` と同じ | + | :c:macro:`PyBUF_RECORDS` | ``(PyBUF_STRIDES | PyBUF_FORMAT | PyBUF_WRITABLE)`` と同じ | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_RECORDS_RO` | ``(PyBUF_STRIDES | PyBUF_FORMAT)`` と同じ | + | :c:macro:`PyBUF_RECORDS_RO` | ``(PyBUF_STRIDES | PyBUF_FORMAT)`` と同じ | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_FULL` | ``(PyBUF_INDIRECT | PyBUF_FORMAT | PyBUF_WRITABLE)`` と同じ | + | :c:macro:`PyBUF_FULL` | ``(PyBUF_INDIRECT | PyBUF_FORMAT | PyBUF_WRITABLE)`` と同じ | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_FULL_RO` | ``(PyBUF_INDIRECT | PyBUF_FORMAT)`` と同じ | + | :c:macro:`PyBUF_FULL_RO` | ``(PyBUF_INDIRECT | PyBUF_FORMAT)`` と同じ | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_CONTIG` | ``(PyBUF_ND | PyBUF_WRITABLE)`` と同じ | + | :c:macro:`PyBUF_CONTIG` | ``(PyBUF_ND | PyBUF_WRITABLE)`` と同じ | +-----------------------------------+--------------------------------------------------------------+ - | :cmacro:`PyBUF_CONTIG_RO` | ``(PyBUF_ND)`` と同 じ | + | :c:macro:`PyBUF_CONTIG_RO` | ``(PyBUF_ND)`` と同 じ | +-----------------------------------+--------------------------------------------------------------+ @@ -240,7 +240,7 @@ .. cfunction:: Py_ssize_t PyBuffer_SizeFromFormat(const char *) - :cdata:`~Py_buffer.itemsize` の値を :cdata:`~PyBuffer.format` から返 します。 + :c:data:`~Py_buffer.itemsize` の値を :c:data:`~PyBuffer.format` から 返します。 .. cfunction:: int PyObject_CopyToObject(PyObject *obj, void *buf, Py_ssize_t len, char fortran) @@ -287,7 +287,7 @@ .. index:: single: PyBufferProcs バッファインタフェースに関するより詳しい情報は、 "バッファオブジェクト構造 体" 節 ( :ref:`buffer-structs` 節) の、 -:ctype:`PyBufferProcs` の説明のところにあります。 +:c:type:`PyBufferProcs` の説明のところにあります。 "バッファオブジェクト" はヘッダファイル :file:`bufferobject.h` の中で定義 されています (このファイルは :file:`Python.h` がインクルードしています)。バッファオブジェクトは、 Python プログラミングの @@ -304,28 +304,28 @@ .. ctype:: PyBufferObject - この :ctype:`PyObject` のサブタイプはバッファオブジェクトを表現します。 + この :c:type:`PyObject` のサブタイプはバッファオブジェクトを表現します。 .. cvar:: PyTypeObject PyBuffer_Type .. index:: single: BufferType (in module types) - Python バッファ型 (buffer type) を表現する :ctype:`PyTypeObject` です; Python レイヤにおける + Python バッファ型 (buffer type) を表現する :c:type:`PyTypeObject` です; Python レイヤにおける ``buffer`` や ``types.BufferType`` と同じオブジェクトです。 .. cvar:: int Py_END_OF_BUFFER - この定数は、 :cfunc:`PyBuffer_FromObject` または の :cfunc:`PyBuffer_FromReadWriteObject` - *size* パラメタに渡します。このパラメタを渡す と、 :ctype:`PyBufferObject` は指定された *offset* + この定数は、 :c:func:`PyBuffer_FromObject` または の :c:func:`PyBuffer_FromReadWriteObject` + *size* パラメタに渡します。このパラメタを渡す と、 :c:type:`PyBufferObject` は指定された *offset* からバッファの終わりまでを *base* オブジェクトとして参照します。このパラ メタを使うことで、関数の呼び出し側が *base* オブジェクト のサイズを調べる必要がなくなります。 .. cfunction:: int PyBuffer_Check(PyObject *p) - 引数が :cdata:`PyBuffer_Type` 型のときに真を返します。 + 引数が :c:data:`PyBuffer_Type` 型のときに真を返します。 .. cfunction:: PyObject* PyBuffer_FromObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size) @@ -338,16 +338,16 @@ 末尾までにわたります。 .. versionchanged:: 2.5 - この関数は以前は *offset*, *size* の型に :ctype:`int` を利用していま した。 + この関数は以前は *offset*, *size* の型に :c:type:`int` を利用していま した。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyBuffer_FromReadWriteObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size) - 新たな書き込み可能バッファオブジェクトを返します。パラメタおよび例外 は :cfunc:`PyBuffer_FromObject` と同じです。 *base* + 新たな書き込み可能バッファオブジェクトを返します。パラメタおよび例外 は :c:func:`PyBuffer_FromObject` と同じです。 *base* オブジェクトが書き込み可能バッファに必要なバッファプロトコルを公開してい ない場合、 :exc:`TypeError` を送出します。 .. versionchanged:: 2.5 - この関数は以前は *offset*, *size* の型に :ctype:`int` を利用していま した。 + この関数は以前は *offset*, *size* の型に :c:type:`int` を利用していま した。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -359,25 +359,25 @@ *なりません* ; 指定すると、 :exc:`ValueError` を送出します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size) - :cfunc:`PyBuffer_FromMemory` に似ていますが、書き込み可能なバッファを返 します。 + :c:func:`PyBuffer_FromMemory` に似ていますが、書き込み可能なバッファを返 します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyBuffer_New(Py_ssize_t size) *size* バイトのメモリバッファを独自に維持する新たな書き込み可能バッファ オブジェクトを返します。 *size* - がゼロまたは正の値でない場合、 :exc:`ValueError` を送出します。 (:cfunc:`PyObject_AsWriteBuffer` + がゼロまたは正の値でない場合、 :exc:`ValueError` を送出します。 (:c:func:`PyObject_AsWriteBuffer` が返すような) メモリバッファは特に整列されていないので注意して下さい。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 ======================================= --- /c-api/bytearray.rst Thu Dec 2 10:20:34 2010 +++ /c-api/bytearray.rst Wed Mar 30 18:55:11 2011 @@ -12,12 +12,12 @@ .. ctype:: PyByteArrayObject - Python の bytearray オブジェクトを示す :ctype:`PyObject` のサブタイプ + Python の bytearray オブジェクトを示す :c:type:`PyObject` のサブタイプ .. cvar:: PyTypeObject PyByteArray_Type - この :ctype:`PyTypeObject` のインスタンスは、 Python bytearray 型を示し ます。 + この :c:type:`PyTypeObject` のインスタンスは、 Python bytearray 型を示し ます。 Python レイヤでの ``bytearray`` と同じオブジェクトです。 型チェックマクロ @@ -78,9 +78,9 @@ .. cfunction:: char* PyByteArray_AS_STRING(PyObject *bytearray) - :cfunc:`PyByteArray_AsString` のマクロバージョン。 + :c:func:`PyByteArray_AsString` のマクロバージョン。 .. cfunction:: Py_ssize_t PyByteArray_GET_SIZE(PyObject *bytearray) - :cfunc:`PyByteArray_Size` のマクロバージョン。 + :c:func:`PyByteArray_Size` のマクロバージョン。 ======================================= --- /c-api/cobject.rst Sun Nov 21 06:00:19 2010 +++ /c-api/cobject.rst Wed Mar 30 18:55:11 2011 @@ -13,41 +13,41 @@ .. ctype:: PyCObject - この :ctype:`PyObject` のサブタイプは不透明型値 (opaque value) を表現し ます。C 拡張モジュールが Python - コードから不透明型値を (:ctype:`void\*` ポインタで) 他の C コードに渡す 必要があるときに便利です。正規の import + この :c:type:`PyObject` のサブタイプは不透明型値 (opaque value) を表現し ます。C 拡張モジュールが Python + コードから不透明型値を (:c:type:`void\*` ポインタで) 他の C コードに渡 す必要があるときに便利です。正規の import 機構を使って動的にロードされるモジュール内で定義されている C API にアク セスするために、あるモジュール内で定義されている C 関数ポインタを別のモジュールでも利用できるようにするためによく使われま す。 .. cfunction:: int PyCObject_Check(PyObject *p) - 引数が :ctype:`PyCObject` の場合に真を返します。 + 引数が :c:type:`PyCObject` の場合に真を返します。 .. cfunction:: PyObject* PyCObject_FromVoidPtr(void* cobj, void (*destr)(void *)) - ``void*`` *cobj* から :ctype:`PyCObject` を生成します。関数 *destr* が *NULL* + ``void*`` *cobj* から :c:type:`PyCObject` を生成します。関数 *destr* が *NULL* でない場合、オブジェクトを再利用する際に呼び出します。 .. cfunction:: PyObject* PyCObject_FromVoidPtrAndDesc(void* cobj, void* desc, void (*destr)(void *, void *)) - ``void*`` *cobj* から :ctype:`PyCObject` を生成します。関数 *destr* が *NULL* + ``void*`` *cobj* から :c:type:`PyCObject` を生成します。関数 *destr* が *NULL* でない場合、オブジェクトを再利用する際に呼び出します。引数 *desc* を使っ て、デストラクタ関数に追加のコールバックデータを渡せます。 .. cfunction:: void* PyCObject_AsVoidPtr(PyObject* self) - :ctype:`PyCObject` オブジェクト *self* を生成するのに用いたオブジェク ト :ctype:`void \*` を返します。 + :c:type:`PyCObject` オブジェクト *self* を生成するのに用いたオブジェク ト :c:type:`void \*` を返します。 .. cfunction:: void* PyCObject_GetDesc(PyObject* self) - :ctype:`PyCObject` オブジェクト *self* を生成するのに用いたコールバック データ :ctype:`void \*` を返します。 + :c:type:`PyCObject` オブジェクト *self* を生成するのに用いたコールバック データ :c:type:`void \*` を返します。 .. cfunction:: int PyCObject_SetVoidPtr(PyObject* self, void* cobj) - *self* 内の void ポインタ *cobj* に設定します。 :ctype:`PyCObject` にデ ストラクタが関連づけられていてはなりません。 + *self* 内の void ポインタ *cobj* に設定します。 :c:type:`PyCObject` にデ ストラクタが関連づけられていてはなりません。 成功すると真値を返し、失敗すると偽値を返します。 ======================================= --- /c-api/complex.rst Sun Nov 21 06:00:19 2010 +++ /c-api/complex.rst Wed Mar 30 18:55:11 2011 @@ -31,32 +31,32 @@ .. cfunction:: Py_complex _Py_c_sum(Py_complex left, Py_complex right) - 二つの複素数の和を C の :ctype:`Py_complex` 型で返します。 + 二つの複素数の和を C の :c:type:`Py_complex` 型で返します。 .. cfunction:: Py_complex _Py_c_diff(Py_complex left, Py_complex right) - 二つの複素数の差を C の :ctype:`Py_complex` 型で返します。 + 二つの複素数の差を C の :c:type:`Py_complex` 型で返します。 .. cfunction:: Py_complex _Py_c_neg(Py_complex complex) - 複素数 *complex* の符号反転 C の :ctype:`Py_complex` 型で返します。 + 複素数 *complex* の符号反転 C の :c:type:`Py_complex` 型で返します。 .. cfunction:: Py_complex _Py_c_prod(Py_complex left, Py_complex right) - 二つの複素数の積を C の :ctype:`Py_complex` 型で返します。 + 二つの複素数の積を C の :c:type:`Py_complex` 型で返します。 .. cfunction:: Py_complex _Py_c_quot(Py_complex dividend, Py_complex divisor) - 二つの複素数の商を C の :ctype:`Py_complex` 型で返します。 + 二つの複素数の商を C の :c:type:`Py_complex` 型で返します。 .. cfunction:: Py_complex _Py_c_pow(Py_complex num, Py_complex exp) - 指数 *exp* の *num* 乗を C の :ctype:`Py_complex` 型で返します。 + 指数 *exp* の *num* 乗を C の :c:type:`Py_complex` 型で返します。 Python オブジェクトとしての複素数型 @@ -65,18 +65,18 @@ .. ctype:: PyComplexObject - この :ctype:`PyObject` のサブタイプは Python の複素数オブジェクトを表現 します。 + この :c:type:`PyObject` のサブタイプは Python の複素数オブジェクトを表現 します。 .. cvar:: PyTypeObject PyComplex_Type - この :ctype:`PyTypeObject` のインスタンスは Python の複素数型を表現しま す。 + この :c:type:`PyTypeObject` のインスタンスは Python の複素数型を表現しま す。 Pythonの ``complex`` や ``types.ComplexType`` と同じオブジェクトです。 .. cfunction:: int PyComplex_Check(PyObject *p) - 引数が :ctype:`PyComplexObject` 型か :ctype:`PyComplexObject` 型のサブタ イプのときに真を返します。 + 引数が :c:type:`PyComplexObject` 型か :c:type:`PyComplexObject` 型のサブ タイプのときに真を返します。 .. versionchanged:: 2.2 サブタイプを引数にとれるようになりました. @@ -84,32 +84,32 @@ .. cfunction:: int PyComplex_CheckExact(PyObject *p) - 引数が :ctype:`PyComplexObject` 型で、かつ :ctype:`PyComplexObject` 型の サブタイプでないときに真を返します。 + 引数が :c:type:`PyComplexObject` 型で、かつ :c:type:`PyComplexObject` 型 のサブタイプでないときに真を返します。 .. versionadded:: 2.2 .. cfunction:: PyObject* PyComplex_FromCComplex(Py_complex v) - C の :ctype:`Py_complex` 型から Python の複素数値を生成します。 + C の :c:type:`Py_complex` 型から Python の複素数値を生成します。 .. cfunction:: PyObject* PyComplex_FromDoubles(double real, double imag) - 新たな :ctype:`PyComplexObject` オブジェクトを *real* と *imag* から生成 します。 + 新たな :c:type:`PyComplexObject` オブジェクトを *real* と *imag* から生 成します。 .. cfunction:: double PyComplex_RealAsDouble(PyObject *op) - *op* の実数部分を C の :ctype:`double` 型で返します。 + *op* の実数部分を C の :c:type:`double` 型で返します。 .. cfunction:: double PyComplex_ImagAsDouble(PyObject *op) - *op* の虚数部分を C の :ctype:`double` 型で返します。 + *op* の虚数部分を C の :c:type:`double` 型で返します。 .. cfunction:: Py_complex PyComplex_AsCComplex(PyObject *op) - 複素数値 *op* から :ctype:`Py_complex` 型を生成します。 - + 複素数値 *op* から :c:type:`Py_complex` 型を生成します。 + ======================================= --- /c-api/concrete.rst Sun Nov 21 06:00:19 2010 +++ /c-api/concrete.rst Wed Mar 30 18:55:11 2011 @@ -12,7 +12,7 @@ Python プログラムから何らかのオブジェクトを受け取ったとき、 そのオブジェクトが正しい型になっているか確信をもてないのなら、 まず型チェックを行わなければなりません; -例えば、あるオブジェクトが辞書型か調べるには、 :cfunc:`PyDict_Check` を使い ます。 +例えば、あるオブジェクトが辞書型か調べるには、 :c:func:`PyDict_Check` を使 います。 この章は Python のオブジェクト型における "家計図" に従って構成されていま す。 .. warning:: ======================================= --- /c-api/conversion.rst Thu Dec 2 09:54:54 2010 +++ /c-api/conversion.rst Wed Mar 30 18:55:11 2011 @@ -21,8 +21,8 @@ *str* に出力します。 Unix man page の :manpage:`vsnprintf(2)` を参照してください。 -:cfunc:`PyOS_snprintf` と :cfunc:`PyOS_vsnprintf` は標準Cライブラリの -:cfunc:`snprintf` と :cfunc:`vsnprintf` 関数をラップします。 +:c:func:`PyOS_snprintf` と :c:func:`PyOS_vsnprintf` は標準Cライブラリの +:c:func:`snprintf` と :c:func:`vsnprintf` 関数をラップします。 これらの関数の目的は、C標準ライブラリが保証していないコーナーケースでの 動作を保証することです。 @@ -31,7 +31,7 @@ ``str != NULL``, ``size > 0``, ``format != NULL`` を要求します。 -もし :cfunc:`vsnprintf` のないプラットフォームで、切り捨てを避けるために必 要な +もし :c:func:`vsnprintf` のないプラットフォームで、切り捨てを避けるために必 要な バッファサイズが *size* を512バイトより大きく超過していれば、 Python は *Py_FatalError* で abort します。 @@ -53,11 +53,11 @@ .. cfunction:: double PyOS_ascii_strtod(const char *nptr, char **endptr) - 文字列を :ctype:`double` へ変換します。 - この関数は、C locale におけるC標準の :cfunc:`strtod` と同じように動作し ます。 + 文字列を :c:type:`double` へ変換します。 + この関数は、C locale におけるC標準の :c:func:`strtod` と同じように動作し ます。 スレッドセーフのために、この関数は現在の locale を変更せずに実装されてい ます。 - :cfunc:`PyOS_ascii_strtod` は通常、設定ファイルを読み込むときや、ロケー ル独立な + :c:func:`PyOS_ascii_strtod` は通常、設定ファイルを読み込むときや、ロケー ル独立な 非ユーザーからの入力を読み込むときに使われるべきです。 .. versionadded:: 2.4 @@ -67,8 +67,8 @@ .. cfunction:: char * PyOS_ascii_formatd(char *buffer, size_t buf_len, const char *format, double d) - :ctype:`double` を ``'.'`` を小数点記号に利用して文字列に変換します。 - *format* は数値のフォーマットを指定する :cfunc:`printf` スタイルの文字列 です。 + :c:type:`double` を ``'.'`` を小数点記号に利用して文字列に変換します。 + *format* は数値のフォーマットを指定する :c:func:`printf` スタイルの文字 列です。 利用できる変換文字は ``'e'``, ``'E'``, ``'f'``, ``'F'``, ``'g'``, ``'G'`` です。 戻り値は、変換された文字列が格納された *buffer* へのポインタか、失敗した 場合は NULL です。 @@ -78,7 +78,7 @@ .. cfunction:: double PyOS_ascii_atof(const char *nptr) - 文字列を、 locale 非依存な方法で :ctype:`double` へ変換します。 + 文字列を、 locale 非依存な方法で :c:type:`double` へ変換します。 .. versionadded:: 2.4 @@ -88,7 +88,7 @@ .. cfunction:: char * PyOS_stricmp(char *s1, char *s2) 大文字/小文字を区別しない文字列比較。 - 大文字/小文字を無視する以外は、 :cfunc:`strcmp` と同じ動作をします。 + 大文字/小文字を無視する以外は、 :c:func:`strcmp` と同じ動作をします。 .. versionadded:: 2.6 @@ -96,6 +96,6 @@ .. cfunction:: char * PyOS_strnicmp(char *s1, char *s2, Py_ssize_t size) 大文字/小文字を区別しない文字列比較。 - 大文字/小文字を無視する以外は、 :cfunc:`strncmp` と同じ動作をします。 + 大文字/小文字を無視する以外は、 :c:func:`strncmp` と同じ動作をします。 .. versionadded:: 2.6 ======================================= --- /c-api/datetime.rst Mon Dec 6 06:43:32 2010 +++ /c-api/datetime.rst Wed Mar 30 18:55:11 2011 @@ -8,9 +8,9 @@ :mod:`datetime` モジュールでは、様々な日付オブジェクトや時刻オブジェクトを 提供しています。以下に示す関数を使う場合には、あらかじめヘッダファイル :file:`datetime.h` をソースに include し (:file:`Python.h` はこのファイルを -include しません)、 :cmacro:`PyDateTime_IMPORT` マクロを、通常はモジュール +include しません)、 :c:macro:`PyDateTime_IMPORT` マクロを、通常はモジュール 初期化関数から、起動しておく必要があります。このマクロは以下のマクロで -使われる静的変数 :cdata:`PyDateTimeAPI` に C 構造体へのポインタを入れます。 +使われる静的変数 :c:data:`PyDateTimeAPI` に C 構造体へのポインタを入れま す。 .. % DateTime Objects @@ -19,7 +19,7 @@ .. cfunction:: int PyDate_Check(PyObject *ob) - *ob* が :cdata:`PyDateTime_DateType` 型か :cdata:`PyDateTime_DateType` + *ob* が :c:data:`PyDateTime_DateType` 型か :c:data:`PyDateTime_DateType` 型のサブタイプのオブジェクトの場合に真を返します; *ob* は *NULL* であっ てはなりません。 .. versionadded:: 2.4 @@ -27,14 +27,14 @@ .. cfunction:: int PyDate_CheckExact(PyObject *ob) - *ob* が :cdata:`PyDateTime_DateType` 型のオブジェクトの場合に真を返しま す; *ob* は *NULL* であってはなりません。 + *ob* が :c:data:`PyDateTime_DateType` 型のオブジェクトの場合に真を返しま す; *ob* は *NULL* であってはなりません。 .. versionadded:: 2.4 .. cfunction:: int PyDateTime_Check(PyObject *ob) - *ob* が :cdata:`PyDateTime_DateTimeType` 型 か :cdata:`PyDateTime_DateTimeType` + *ob* が :c:data:`PyDateTime_DateTimeType` 型 か :c:data:`PyDateTime_DateTimeType` 型のサブタイプのオブジェクトの場合に真を返します; *ob* は *NULL* であっ てはなりません。 .. versionadded:: 2.4 @@ -42,7 +42,7 @@ .. cfunction:: int PyDateTime_CheckExact(PyObject *ob) - *ob* が :cdata:`PyDateTime_DateTimeType` 型のオブジェクトの場合に真を返 します; *ob* は *NULL* + *ob* が :c:data:`PyDateTime_DateTimeType` 型のオブジェクトの場合に真を返 します; *ob* は *NULL* であってはなりません。 .. versionadded:: 2.4 @@ -50,7 +50,7 @@ .. cfunction:: int PyTime_Check(PyObject *ob) - *ob* が :cdata:`PyDateTime_TimeType` 型か :cdata:`PyDateTime_TimeType` + *ob* が :c:data:`PyDateTime_TimeType` 型か :c:data:`PyDateTime_TimeType` 型のサブタイプのオブジェクトの場合に真を返します; *ob* は *NULL* であっ てはなりません。 .. versionadded:: 2.4 @@ -58,14 +58,14 @@ .. cfunction:: int PyTime_CheckExact(PyObject *ob) - *ob* が :cdata:`PyDateTime_TimeType` 型のオブジェクトの場合に真を返しま す; *ob* は *NULL* であってはなりません。 + *ob* が :c:data:`PyDateTime_TimeType` 型のオブジェクトの場合に真を返しま す; *ob* は *NULL* であってはなりません。 .. versionadded:: 2.4 .. cfunction:: int PyDelta_Check(PyObject *ob) - *ob* が :cdata:`PyDateTime_DeltaType` 型か :cdata:`PyDateTime_DeltaType` + *ob* が :c:data:`PyDateTime_DeltaType` 型 か :c:data:`PyDateTime_DeltaType` 型のサブタイプのオブジェクトの場合に真を返します; *ob* は *NULL* であっ てはなりません。 .. versionadded:: 2.4 @@ -73,7 +73,7 @@ .. cfunction:: int PyDelta_CheckExact(PyObject *ob) - *ob* が :cdata:`PyDateTime_DeltaType` 型のオブジェクトの場合に真を返しま す; *ob* は *NULL* + *ob* が :c:data:`PyDateTime_DeltaType` 型のオブジェクトの場合に真を返し ます; *ob* は *NULL* であってはなりません。 .. versionadded:: 2.4 @@ -81,7 +81,7 @@ .. cfunction:: int PyTZInfo_Check(PyObject *ob) - *ob* が :cdata:`PyDateTime_TZInfoType` 型 か :cdata:`PyDateTime_TZInfoType` + *ob* が :c:data:`PyDateTime_TZInfoType` 型 か :c:data:`PyDateTime_TZInfoType` 型のサブタイプのオブジェクトの場合に真を返します; *ob* は *NULL* であっ てはなりません。 .. versionadded:: 2.4 @@ -89,7 +89,7 @@ .. cfunction:: int PyTZInfo_CheckExact(PyObject *ob) - *ob* が :cdata:`PyDateTime_TZInfoType` 型のオブジェクトの場合に真を返し ます; *ob* は *NULL* + *ob* が :c:data:`PyDateTime_TZInfoType` 型のオブジェクトの場合に真を返し ます; *ob* は *NULL* であってはなりません。 .. versionadded:: 2.4 @@ -125,8 +125,8 @@ .. versionadded:: 2.4 -以下のマクロは date オブジェクトからフィールド値を取り出すためのものです。 引数は :cdata:`PyDateTime_Date` またはそのサブクラス -(例えば :cdata:`PyDateTime_DateTime`)の インスタンスでなければなりません。 引数を *NULL* にしてはならず、 +以下のマクロは date オブジェクトからフィールド値を取り出すためのものです。 引数は :c:data:`PyDateTime_Date` またはそのサブクラス +(例えば :c:data:`PyDateTime_DateTime`)の インスタンスでなければなりませ ん。引数を *NULL* にしてはならず、 型チェックは行いません: @@ -150,7 +150,7 @@ .. versionadded:: 2.4 -以下のマクロは datetime オブジェクトからフィールド値を取り出すためのもので す。引数は :cdata:`PyDateTime_DateTime` +以下のマクロは datetime オブジェクトからフィールド値を取り出すためのもので す。引数は :c:data:`PyDateTime_DateTime` またはそのサブクラスのインスタンスでなければなりません。引数を *NULL* にし てはならず、型チェックは行いません: @@ -181,7 +181,7 @@ .. versionadded:: 2.4 -以下のマクロは time オブジェクトからフィールド値を取り出すためのものです。 引数は :cdata:`PyDateTime_Time` またはそのサブクラスの +以下のマクロは time オブジェクトからフィールド値を取り出すためのものです。 引数は :c:data:`PyDateTime_Time` またはそのサブクラスの インスタンスでなければなりません。引数を *NULL* にしてはならず、型チェック は行いません: ======================================= --- /c-api/dict.rst Tue Nov 30 20:35:03 2010 +++ /c-api/dict.rst Wed Mar 30 18:55:11 2011 @@ -10,7 +10,7 @@ .. ctype:: PyDictObject - この :ctype:`PyObject` のサブタイプは Python の辞書オブジェクトを表現し ます。 + この :c:type:`PyObject` のサブタイプは Python の辞書オブジェクトを表現し ます。 .. cvar:: PyTypeObject PyDict_Type @@ -19,13 +19,13 @@ single: DictType (in module types) single: DictionaryType (in module types) - この :ctype:`PyTypeObject` のインスタンスは Python の辞書を表現します。 このオブジェクトは、Python プログラムには + この :c:type:`PyTypeObject` のインスタンスは Python の辞書を表現します。 このオブジェクトは、Python プログラムには ``dict`` および ``types.DictType`` として公開されています。 .. cfunction:: int PyDict_Check(PyObject *p) - 引数が :ctype:`PyDictObject` のときに真を返します。 + 引数が :c:type:`PyDictObject` のときに真を返します。 .. cfunction:: int PyDict_CheckExact(PyObject *p) @@ -79,7 +79,7 @@ .. index:: single: PyString_FromString() - 辞書 *p* に、 *key* をキーとして値 *value* を挿入します。 *key* は :ctype:`char\*` 型でなければなりません。 + 辞書 *p* に、 *key* をキーとして値 *value* を挿入します。 *key* は :c:type:`char\*` 型でなければなりません。 キーオブジェクトは ``PyString_FromString(key)`` で生成されます。成功した 場合には ``0`` を、失敗した場合には ``-1`` を返します。 @@ -103,27 +103,27 @@ .. cfunction:: PyObject* PyDict_GetItemString(PyObject *p, const char *key) - :cfunc:`PyDict_GetItem` と同じですが、 *key* は :ctype:`PyObject\*` では なく :ctype:`char\*` + :c:func:`PyDict_GetItem` と同じですが、 *key* は :c:type:`PyObject\*` で はなく :c:type:`char\*` で指定します。 .. cfunction:: PyObject* PyDict_Items(PyObject *p) - 辞書オブジェクトのメソッド :meth:`item` のように、辞書内の全ての要素対が 入った :ctype:`PyListObject` を返します。 + 辞書オブジェクトのメソッド :meth:`item` のように、辞書内の全ての要素対が 入った :c:type:`PyListObject` を返します。 (:meth:`items` については Python ライブラリリファレンス (XXX reference: ../lib/lib.html) を 参照してください。) .. cfunction:: PyObject* PyDict_Keys(PyObject *p) - 辞書オブジェクトのメソッド :meth:`keys` のように、辞書内の全てのキーが入 った :ctype:`PyListObject` を返します。 + 辞書オブジェクトのメソッド :meth:`keys` のように、辞書内の全てのキーが入 った :c:type:`PyListObject` を返します。 (:meth:`keys` については Python ライブラリリファレンス (XXX reference: ../lib/lib.html) を 参照してください。) .. cfunction:: PyObject* PyDict_Values(PyObject *p) - 辞書オブジェクトのメソッド :meth:`values` のように、辞書内の全ての値が入 った :ctype:`PyListObject` を返します。 + 辞書オブジェクトのメソッド :meth:`values` のように、辞書内の全ての値が入 った :c:type:`PyListObject` を返します。 (:meth:`values` については Python ライブラリリファレンス (XXX reference: ../lib/lib.html) を 参照してください。) @@ -135,13 +135,13 @@ 辞書内の要素の数を返します。辞書に対して ``len(p)`` を実行するのと同じで す。 .. versionchanged:: 2.5 - この関数は以前は :ctype:`int` を返していました。 + この関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PyDict_Next(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue) 辞書 *p* 内の全てのキー/値のペアにわたる反復処理を行います。 - *ppos* が参照している :ctype:`Py_ssize_t` 型は、この関数で反復処理を開始 する際に、 + *ppos* が参照している :c:type:`Py_ssize_t` 型は、この関数で反復処理を開 始する際に、 最初に関数を呼び出すよりも前に ``0`` に初期化しておかなければなりません; この関数は辞書内の各ペアを取り上げるごとに真を返し、 全てのペアを取り上げたことが分かると偽を返します。 @@ -182,7 +182,7 @@ } .. versionchanged:: 2.5 - この関数は以前は *ppos* の型に :ctype:`int *` を利用していました。 + この関数は以前は *ppos* の型に :c:type:`int *` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PyDict_Merge(PyObject *a, PyObject *b, int override) ======================================= --- /c-api/exceptions.rst Sun Nov 28 09:02:22 2010 +++ /c-api/exceptions.rst Wed Mar 30 18:55:11 2011 @@ -8,10 +8,10 @@ ******** この章で説明する関数を使うと、Pythonの例外の処理や送出ができるようになりま す。Pythonの例外処理の基本をいくらか理解することが大切です。 -例外はUnix :cdata:`errno` 変数にやや似た機能を果たします: 発生した +例外はUnix :c:data:`errno` 変数にやや似た機能を果たします: 発生した 中で最も新しいエラーの(スレッド毎の)グローバルなインジケータがあります。実 行に成功した場合にはほとんどの関数がこれをクリアしませんが、失敗したときには エラーの原因を示すために設定します。ほとんどの関数はエラーインジケータも返 し、通常は関数がポインタを返すことになっている場合は *NULL* であり、 -関数が整数を返す場合は ``-1`` です。(例外: :cfunc:`PyArg_\*` 関数は +関数が整数を返す場合は ``-1`` です。(例外: :c:func:`PyArg_\*` 関数は 実行に成功したときに ``1`` を返し、失敗したときに ``0`` を返します). ある関数が呼び出した関数がいくつか失敗したために、その関数が失敗しなければ ならないとき、一般的にエラーインジケータを設定しません。呼び出した関数が @@ -50,13 +50,13 @@ .. cfunction:: PyObject* PyErr_Occurred() - エラーインジケータが設定されているかテストします。設定されている場合は、 例外の *型* (:cfunc:`PyErr_Set\*` 関数の一つあるいは - :cfunc:`PyErr_Restore` への最も新しい呼び出しに対する第一引数)を返しま す。 - 設定されていない場合は *NULL* を返します。あなたは戻り値への参照を持って いませんので、それに :cfunc:`Py_DECREF` する必要はありません。 + エラーインジケータが設定されているかテストします。設定されている場合は、 例外の *型* (:c:func:`PyErr_Set\*` 関数の一つあるいは + :c:func:`PyErr_Restore` への最も新しい呼び出しに対する第一引数)を返しま す。 + 設定されていない場合は *NULL* を返します。あなたは戻り値への参照を持って いませんので、それに :c:func:`Py_DECREF` する必要はありません。 .. note:: - 戻り値を特定の例外と比較しないでください。その代わり、下に示 す :cfunc:`PyErr_ExceptionMatches` を + 戻り値を特定の例外と比較しないでください。その代わり、下に示 す :c:func:`PyErr_ExceptionMatches` を 使ってください。(比較は簡単に失敗するでしょう。なぜなら、例外はクラス ではなくインスタンスかもしれないし、あるいは、クラス例外の場合は期待される例 外の サブクラスかもしれないからです。) @@ -77,7 +77,7 @@ .. cfunction:: void PyErr_NormalizeException(PyObject**exc, PyObject**val, PyObject**tb) - ある状況では、以下の :cfunc:`PyErr_Fetch` が返す値は "正規化されていな い"可能性があります。つまり、 ``*exc`` は + ある状況では、以下の :c:func:`PyErr_Fetch` が返す値は "正規化されていな い"可能性があります。つまり、 ``*exc`` は クラスオブジェクトだが ``*val`` は同じクラスのインスタンスではないという 意味です。この関数はそのような場合にそのクラスをインスタンス化 するために使われます。その値がすでに正規化されている場合は何も起きませ ん。遅延正規化はパフォーマンスを改善するために実装されています。 @@ -110,26 +110,26 @@ .. note:: 通常この関数はエラーインジケータを一時的に保存し元に戻す必要のある コードによってのみに使われます。現在の例外状態を保存するためには - :cfunc:`PyErr_Fetch` を使ってください。 + :c:func:`PyErr_Fetch` を使ってください。 .. cfunction:: void PyErr_SetString(PyObject *type, const char *message) これはエラーインジケータを設定するための最も一般的な方法です。第一引数は - 例外の型を指定します。通常は標準例外の一つ、例え ば :cdata:`PyExc_RuntimeError` です。 + 例外の型を指定します。通常は標準例外の一つ、例え ば :c:data:`PyExc_RuntimeError` です。 その参照カウントを増加させる必要はありません。第二引数はエラーメッセージ で、文字列オブジェクトへ変換されます。 .. cfunction:: void PyErr_SetObject(PyObject *type, PyObject *value) - この関数は :cfunc:`PyErr_SetString` に似ていますが、 + この関数は :c:func:`PyErr_SetString` に似ていますが、 例外の"値(value)"として任意のPythonオブジェクトを指定することができま す。 .. cfunction:: PyObject* PyErr_Format(PyObject *exception, const char *format, ...) この関数はエラーインジケータを設定し *NULL* を返します。 *exception* は Python例外(インスタンスではなくクラス)であるべきです。 - *format* は文字列であるべきであり、 :cfunc:`printf` に似た + *format* は文字列であるべきであり、 :c:func:`printf` に似た 書式化コードを含んでいます。書式化コードの前の ``幅.精度 (width.precision)`` は解析されますが、幅の部分は無視されます。 .. % \begin{tableii}{c|l}{character}{文字}{意味} @@ -201,18 +201,18 @@ .. index:: single: strerror() - Cライブラリ関数がエラーを返してC変数 :cdata:`errno` を設定したときに、こ れは例外を発生させるために便利な関数です。第一要素が - 整数 :cdata:`errno` 値で、第二要素が (:cfunc:`strerror` から得られる)対 応する + Cライブラリ関数がエラーを返してC変数 :c:data:`errno` を設定したときに、 これは例外を発生させるために便利な関数です。第一要素が + 整数 :c:data:`errno` 値で、第二要素が (:c:func:`strerror` から得られる )対応する エラーメッセージであるタプルオブジェクトを構成します。それから、 ``PyErr_SetObject(type, object)`` を呼び出します。 - Unixでは、 :cdata:`errno` 値が :const:`EINTR` であるとき、すなわち割り込 まれたシステムコールを表しているとき、これは - :cfunc:`PyErr_CheckSignals` を呼び出し、それがエラーインジケータを + Unixでは、 :c:data:`errno` 値が :const:`EINTR` であるとき、すなわち割り 込まれたシステムコールを表しているとき、これは + :c:func:`PyErr_CheckSignals` を呼び出し、それがエラーインジケータを 設定した場合は設定されたままにしておきます。関数は常に *NULL* を返しま す。したがって、システムコールがエラーを返したとき、システムコールの ラッパー関数は ``return PyErr_SetFromErrno(type);`` と書くことができま す。 .. cfunction:: PyObject* PyErr_SetFromErrnoWithFilename(PyObject *type, const char *filename) - :cfunc:`PyErr_SetFromErrno` に似ていて、 *filename* が *NULL* でない場合 に、 + :c:func:`PyErr_SetFromErrno` に似ていて、 *filename* が *NULL* でない場 合に、 それが *type* のコンストラクタに第三引数として渡されるというふるまいが追 加 されています。 :exc:`IOError` と :exc:`OSError` のような例外の場合では、 これが例外インスタンスの :attr:`filename` 属性を定義するために使われま す。 @@ -221,17 +221,17 @@ .. cfunction:: PyObject* PyErr_SetFromWindowsErr(int ierr) これは :exc:`WindowsError` を発生させるために便利な関数です。 - :cdata:`0` の *ierr* とともに呼び出された場合、 :cfunc:`GetLastError` が - 返すエラーコードが代りに使われます。 *ierr* あるい は :cfunc:`GetLastError` によって与えられるエラーコードのWindows用の説明を - 取り出すために、Win32関数 :cfunc:`FormatMessage` を呼び出します。それか ら、 - 第一要素が *ierr* 値で第二要素が(:cfunc:`FormatMessage` から得られる) + :c:data:`0` の *ierr* とともに呼び出された場合、 :c:func:`GetLastError` が + 返すエラーコードが代りに使われます。 *ierr* あるい は :c:func:`GetLastError` によって与えられるエラーコードのWindows用の説明を + 取り出すために、Win32関数 :c:func:`FormatMessage` を呼び出します。それか ら、 + 第一要素が *ierr* 値で第二要素が(:c:func:`FormatMessage` から得られる) 対応するエラーメッセージであるタプルオブジェクトを構成します。そして、 ``PyErr_SetObject(PyExc_WindowsError, object)`` を呼び出します。この関数は常に *NULL* を返します。利用可能範 囲: Windows。 .. cfunction:: PyObject* PyErr_SetExcFromWindowsErr(PyObject *type, int ierr) - :cfunc:`PyErr_SetFromWindowsErr` に似ていて、送出する例外の型を指定する 引数が追加されています。利用可能範囲: + :c:func:`PyErr_SetFromWindowsErr` に似ていて、送出する例外の型を指定する 引数が追加されています。利用可能範囲: Windows。 .. versionadded:: 2.3 @@ -239,13 +239,13 @@ .. cfunction:: PyObject* PyErr_SetFromWindowsErrWithFilename(int ierr, const char *filename) - :cfunc:`PyErr_SetFromWindowsErr` に似ていて、 *filename* が *NULL* でな い場合には + :c:func:`PyErr_SetFromWindowsErr` に似ていて、 *filename* が *NULL* でな い場合には :exc:`WindowsError` のコンストラクタへ第三引数として渡されるという振る舞 いが追加されています。利用可能範囲: Windows。 .. cfunction:: PyObject* PyErr_SetExcFromWindowsErrWithFilename(PyObject *type, int ierr, char *filename) - :cfunc:`PyErr_SetFromWindowsErrWithFilename` に似ていて、発生させる例外 の型を指定する引数が追加されています。 + :c:func:`PyErr_SetFromWindowsErrWithFilename` に似ていて、発生させる例外 の型を指定する引数が追加されています。 利用可能範囲: Windows。 .. versionadded:: 2.3 @@ -262,25 +262,25 @@ 警告メッセージを出します。 *category* 引数は警告カテゴリ(以下を参照) かまたは *NULL* で、 *message* 引数はメッセージ文字列です。 *stacklevel* はフレームの数を示す正の整数です; - 警告はそのスタックフレームの中の実行している行から発行されます。 *stacklevel* が1だと、 :cfunc:`PyErr_WarnEx` が、2だと + 警告はそのスタックフレームの中の実行している行から発行されます。 *stacklevel* が1だと、 :c:func:`PyErr_WarnEx` が、2だと その上の関数が、Warningの発行元になります。 この関数は通常警告メッセージを *sys.stderr* へプリントします。けれども、 ユーザが警告をエラーへ変更するように指定することも可能です。 そのような場合には、これは例外を発生させます。警告機構がもつ問題のために その関数が例外を発生させるということも可能です。(実装ではその厄介な仕事を 行うために :mod:`warnings` モジュールをインポートします)。例外が発生させ られなければ、戻り値は ``0`` です。あるいは、例外が発生させ られると ``-1`` です。(警告メッセージが実際にプリントされるかどうかを決 定することはできず、また何がその例外の原因なのかを決定することもできない。 - これは意図的なものです。)例外が発生した場合、呼び出し元は通常の例外処理 を行います(例えば、 :cfunc:`Py_DECREF` は参照を持っており、エラー値を + これは意図的なものです。)例外が発生した場合、呼び出し元は通常の例外処理 を行います(例えば、 :c:func:`Py_DECREF` は参照を持っており、エラー値を 返します)。 - 警告カテゴリは :cdata:`Warning` のサブクラスでなければならない。デフォル ト警告カテゴリは :cdata:`RuntimeWarning` です。 + 警告カテゴリは :c:data:`Warning` のサブクラスでなければならない。デフォ ルト警告カテゴリは :c:data:`RuntimeWarning` です。 標準Python警告カテゴリは ``PyExc_`` にPython例外名が続く名前の - グローバル変数を用いて変更できます。これらは型 :ctype:`PyObject\*` を持 ち、すべてクラスオブジェクトです。それらの名前は - :cdata:`PyExc_Warning`, :cdata:`PyExc_UserWarning`, - :cdata:`PyExc_UnicodeWarning`, :cdata:`PyExc_DeprecationWarning`, - :cdata:`PyExc_SyntaxWarning`, :cdata:`PyExc_RuntimeWarning`, - :cdata:`PyExc_FutureWarning` です。 - :cdata:`PyExc_Warning` は :cdata:`PyExc_Exception` のサブクラスです。 - その他の警告カテゴリは :cdata:`PyExc_Warning` のサブクラスです。 + グローバル変数を用いて変更できます。これらは型 :c:type:`PyObject\*` を持 ち、すべてクラスオブジェクトです。それらの名前は + :c:data:`PyExc_Warning`, :c:data:`PyExc_UserWarning`, + :c:data:`PyExc_UnicodeWarning`, :c:data:`PyExc_DeprecationWarning`, + :c:data:`PyExc_SyntaxWarning`, :c:data:`PyExc_RuntimeWarning`, + :c:data:`PyExc_FutureWarning` です。 + :c:data:`PyExc_Warning` は :c:data:`PyExc_Exception` のサブクラスです。 + その他の警告カテゴリは :c:data:`PyExc_Warning` のサブクラスです。 警告をコントロールするための情報については、 :mod:`warnings` モジュール のドキュメンテーションとコマンドライン・ドキュメンテーションの :option:`-W` オプションを参照してください。警告コントロールのためのC APIはありません。 @@ -289,10 +289,10 @@ .. cfunction:: int PyErr_Warn(PyObject *category, char *message) 警告メッセージを出します。 *category* 引数は警告カテゴリ(以下を参照) か または *NULL* で、 *message* 引数はメッセージ文字列です。警告は - 、 :cfunc:`PyErr_WarnEx` を *stacklevel* に 1 を指定した時と同じ く、 :cfunc:`PyErr_Warn` + 、 :c:func:`PyErr_WarnEx` を *stacklevel* に 1 を指定した時と同じ く、 :c:func:`PyErr_Warn` を呼び出した関数から発行されます。 - 非推奨; :cfunc:`PyErr_WarnEx` を使って下さい。 + 非推奨; :c:func:`PyErr_WarnEx` を使って下さい。 .. cfunction:: int PyErr_WarnExplicit(PyObject *category, const char *message, const char *filename, int lineno, const char *module, PyObject *registry) @@ -306,8 +306,8 @@ .. cfunction:: int PyErr_WarnPy3k(char *message, int stacklevel) Issue a :exc:`DeprecationWarning` with the given *message* and *stacklevel* - if the :cdata:`Py_Py3kWarningFlag` flag is enabled. - :cdata:`Py_Py3kWarningFlag` フラグが有効な場合、 + if the :c:data:`Py_Py3kWarningFlag` flag is enabled. + :c:data:`Py_Py3kWarningFlag` フラグが有効な場合、 与えられた *message* と *stacklevel* に応じて :exc:`DeprecationWarning` を発生させます。 .. versionadded:: 2.6 @@ -334,7 +334,7 @@ single: KeyboardInterrupt (built-in exception) この関数は廃止されています。 :const:`SIGINT` シグナルが到達した影響をシ ミュレートします --- 次に - :cfunc:`PyErr_CheckSignals` が呼ばれるとき、 + :c:func:`PyErr_CheckSignals` が呼ばれるとき、 :exc:`KeyboardInterrupt` は送出されるでしょう。インタプリタロックを保持 することなく呼び出すことができます。 @@ -355,7 +355,7 @@ このユーティリティ関数は新しい例外オブジェクトを作成して返します。 *name* 引数は新しい例外の名前、 ``module.class`` 形式の C文字列でなければならない。 *base* と *dict* 引数は通常 *NULL* です。 これはすべての例外のためのルート、組み込み名 :exc:`Exception` - (Cでは :cdata:`PyExc_Exception` としてアクセス可能)を根として導出された クラスオブジェクトを作成します。 + (Cでは :c:data:`PyExc_Exception` としてアクセス可能)を根として導出された クラスオブジェクトを作成します。 新しいクラスの :attr:`__module__` 属性は *name* 引数の前半部分(最後のド ットまで)に 設定され、クラス名は後半部分(最後のドットの後)に設定されます。 *base* 引 数は代わりのベースクラスを指定するために使えます; 一つのクラスでも、 @@ -378,70 +378,70 @@ ======== ``PyExc_`` の後ろにPythonの例外名が続く名前をもつグローバル変数として、 -すべての標準Python例外が利用可能です。これらは型 :ctype:`PyObject\*` を +すべての標準Python例外が利用可能です。これらは型 :c:type:`PyObject\*` を 持ち、すべてクラスオブジェクトです。完璧を期するために、すべての変数を以下 に列挙します: -+------------------------------------+----------------------------+----------+ -| C名 | Python名 | 注 記 | -+====================================+============================+==========+ -| :cdata:`PyExc_BaseException` | :exc:`BaseException` | (1), (4) | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_Exception` | :exc:`Exception` | \(1) | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_StandardError` | :exc:`StandardError` | \(1) | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_ArithmeticError` | :exc:`ArithmeticError` | \(1) | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_LookupError` | :exc:`LookupError` | \(1) | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_AssertionError` | :exc:`AssertionError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_AttributeError` | :exc:`AttributeError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_EOFError` | :exc:`EOFError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_EnvironmentError` | :exc:`EnvironmentError` | \(1) | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_FloatingPointError` | :exc:`FloatingPointError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_IOError` | :exc:`IOError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_ImportError` | :exc:`ImportError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_IndexError` | :exc:`IndexError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_KeyError` | :exc:`KeyError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_KeyboardInterrupt` | :exc:`KeyboardInterrupt` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_MemoryError` | :exc:`MemoryError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_NameError` | :exc:`NameError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_NotImplementedError` | :exc:`NotImplementedError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_OSError` | :exc:`OSError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_OverflowError` | :exc:`OverflowError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_ReferenceError` | :exc:`ReferenceError` | \(2) | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_RuntimeError` | :exc:`RuntimeError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_SyntaxError` | :exc:`SyntaxError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_SystemError` | :exc:`SystemError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_SystemExit` | :exc:`SystemExit` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_TypeError` | :exc:`TypeError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_ValueError` | :exc:`ValueError` | | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_WindowsError` | :exc:`WindowsError` | \(3) | -+------------------------------------+----------------------------+----------+ -| :cdata:`PyExc_ZeroDivisionError` | :exc:`ZeroDivisionError` | | -+------------------------------------+----------------------------+----------+ ++---------------------------------------+----------------------------+----------+ +| C名 | Python名 | 注 記 | ++=======================================+============================+==========+ +| :c:data:`PyExc_BaseException` | :exc:`BaseException` | (1), (4) | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_Exception` | :exc:`Exception` | \(1) | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_StandardError` | :exc:`StandardError` | \(1) | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_ArithmeticError` | :exc:`ArithmeticError` | \(1) | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_LookupError` | :exc:`LookupError` | \(1) | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_AssertionError` | :exc:`AssertionError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_AttributeError` | :exc:`AttributeError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_EOFError` | :exc:`EOFError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_EnvironmentError` | :exc:`EnvironmentError` | \(1) | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_FloatingPointError` | :exc:`FloatingPointError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_IOError` | :exc:`IOError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_ImportError` | :exc:`ImportError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_IndexError` | :exc:`IndexError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_KeyError` | :exc:`KeyError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_KeyboardInterrupt` | :exc:`KeyboardInterrupt` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_MemoryError` | :exc:`MemoryError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_NameError` | :exc:`NameError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_NotImplementedError` | :exc:`NotImplementedError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_OSError` | :exc:`OSError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_OverflowError` | :exc:`OverflowError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_ReferenceError` | :exc:`ReferenceError` | \(2) | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_RuntimeError` | :exc:`RuntimeError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_SyntaxError` | :exc:`SyntaxError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_SystemError` | :exc:`SystemError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_SystemExit` | :exc:`SystemExit` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_TypeError` | :exc:`TypeError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_ValueError` | :exc:`ValueError` | | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_WindowsError` | :exc:`WindowsError` | \(3) | ++---------------------------------------+----------------------------+----------+ +| :c:data:`PyExc_ZeroDivisionError` | :exc:`ZeroDivisionError` | | ++---------------------------------------+----------------------------+----------+ .. index:: single: PyExc_BaseException ======================================= --- /c-api/file.rst Tue Nov 30 22:23:20 2010 +++ /c-api/file.rst Wed Mar 30 18:55:11 2011 @@ -8,13 +8,13 @@ .. index:: object: file Python の組み込みファイルオブジェクトは、全て標準 C ライブラリの -:ctype:`FILE\*` サポートの上に実装されています。以下の詳細説明は +:c:type:`FILE\*` サポートの上に実装されています。以下の詳細説明は 一実装に関するもので、将来の Python のリリースで変更されるかもしれません。 .. ctype:: PyFileObject - この :ctype:`PyObject` のサブタイプは Python のファイル型オブジェクトを + この :c:type:`PyObject` のサブタイプは Python のファイル型オブジェクトを 表現します。 @@ -22,14 +22,14 @@ .. index:: single: FileType (in module types) - この :ctype:`PyTypeObject` のインスタンスは Python のファイル型を表現し ます。 + この :c:type:`PyTypeObject` のインスタンスは Python のファイル型を表現し ます。 このオブジェクトは ``file`` および ``types.FileType`` として Python プログラムで公開されています。 .. cfunction:: int PyFile_Check(PyObject *p) - 引数が :ctype:`PyFileObject` か :ctype:`PyFileObject` のサブタイプのとき に + 引数が :c:type:`PyFileObject` か :c:type:`PyFileObject` のサブタイプのと きに 真を返します。 .. versionchanged:: 2.2 @@ -38,7 +38,7 @@ .. cfunction:: int PyFile_CheckExact(PyObject *p) - 引数が :ctype:`PyFileObject` 型で、かつ :ctype:`PyFileObject` 型の + 引数が :c:type:`PyFileObject` 型で、かつ :c:type:`PyFileObject` 型の サブタイプでないときに真を返します。 .. versionadded:: 2.2 @@ -50,40 +50,40 @@ 成功すると、 *filename* に指定した名前のファイルを *mode* に指定した ファイルモードで開いて得た新たなファイルオブジェクトを返します。 - *mode* のセマンティクスは標準 C ルーチン :cfunc:`fopen` と同じです。 + *mode* のセマンティクスは標準 C ルーチン :c:func:`fopen` と同じです。 失敗すると *NULL* を返します。 .. cfunction:: PyObject* PyFile_FromFile(FILE *fp, char *name, char *mode, int (*close)(FILE*)) すでに開かれている標準 C ファイルポインタ *fp* から新たな - :ctype:`PyFileObject` を生成します。この関数で生成したファイルオブジェク ト + :c:type:`PyFileObject` を生成します。この関数で生成したファイルオブジェ クト は、閉じる際に *close* に指定した関数を呼び出します。失敗すると *NULL* を返します。 .. cfunction:: FILE* PyFile_AsFile(PyObject *p) - *p* に関連付けられたファイルオブジェクトを :ctype:`FILE\*` で返します。 - - 呼び出し側が GIL を開放している間もこの関数が返した :ctype:`FILE\*` - オブジェクトを使うのであれば、以下に解説されてい る :cfunc:`PyFile_IncUseCount` - と :cfunc:`PyFile_DecUseCount` 関数を適切に呼び出さなければなりません。 + *p* に関連付けられたファイルオブジェクトを :c:type:`FILE\*` で返します。 + + 呼び出し側が GIL を開放している間もこの関数が返した :c:type:`FILE\*` + オブジェクトを使うのであれば、以下に解説されてい る :c:func:`PyFile_IncUseCount` + と :c:func:`PyFile_DecUseCount` 関数を適切に呼び出さなければなりません。 .. cfunction:: void PyFile_IncUseCount(PyFileObject \*p) - PyFileObject 内部の、 :ctype:`FILE\*` が使用中であることを示す使用数カウ ント + PyFileObject 内部の、 :c:type:`FILE\*` が使用中であることを示す使用数カ ウント をインクリメントします。 - これは、別のスレッドで使用中の :ctype:`FILE\*` に対して Python が + これは、別のスレッドで使用中の :c:type:`FILE\*` に対して Python が fclose() を呼び出すことを防ぎます。 - この関数の呼び出し側は、 :ctype:`FILE\*` を使い終わったときに必ず - :cfunc:`PyFile_DecUseCount` を呼び出さなければなりません。 + この関数の呼び出し側は、 :c:type:`FILE\*` を使い終わったときに必ず + :c:func:`PyFile_DecUseCount` を呼び出さなければなりません。 そうしなければ、 Python はそのファイルオブジェクトを永遠に閉じません。 この関数を呼び出すときは、GILを取得していなければなりません。 - 例えば、 :cfunc:`PyFile_AsFile` を呼び出した直後、GILを開放する + 例えば、 :c:func:`PyFile_AsFile` を呼び出した直後、GILを開放する 前にこの関数を呼び出します。 .. versionadded:: 2.6 @@ -91,10 +91,10 @@ .. cfunction:: void PyFile_DecUseCount(PyFileObject \*p) - PyFileObject 内部の、 :ctype:`FILE\*` が使用中であることを示す unlocked_count - メンバーをデクリメントして、呼び出し元が :ctype:`FILE\*` を使い終わった + PyFileObject 内部の、 :c:type:`FILE\*` が使用中であることを示す unlocked_count + メンバーをデクリメントして、呼び出し元が :c:type:`FILE\*` を使い終わった ことを示します。 - これは、先に行った :cfunc:`PyFile_IncUseCount` の呼び出しを取り消すため + これは、先に行った :c:func:`PyFile_IncUseCount` の呼び出しを取り消すため だけに呼び出されるでしょう。 この関数を呼び出すときは、GILを取得していなければなりません。 @@ -126,7 +126,7 @@ .. index:: single: setvbuf() - :cfunc:`setvbuf` があるシステムでのみ利用できます。 + :c:func:`setvbuf` があるシステムでのみ利用できます。 この関数を呼び出してよいのはファイルオブジェクトの生成直後のみです。 ======================================= --- /c-api/float.rst Mon Nov 29 09:07:22 2010 +++ /c-api/float.rst Wed Mar 30 18:55:11 2011 @@ -10,20 +10,20 @@ .. ctype:: PyFloatObject - この :ctype:`PyObject` のサブタイプは Python 浮動小数点型オブジェクトを 表現します。 + この :c:type:`PyObject` のサブタイプは Python 浮動小数点型オブジェクトを 表現します。 .. cvar:: PyTypeObject PyFloat_Type .. index:: single: FloatType (in modules types) - この :ctype:`PyTypeObject` のインスタンスは Python 浮動小数点型を表現し ます。これは + この :c:type:`PyTypeObject` のインスタンスは Python 浮動小数点型を表現し ます。これは ``float`` や ``types.FloatType`` と同じオブジェクトです。 .. cfunction:: int PyFloat_Check(PyObject *p) - 引数が :ctype:`PyFloatObject` か :ctype:`PyFloatObject` のサブタイプのと きに真を返します。 + 引数が :c:type:`PyFloatObject` か :c:type:`PyFloatObject` のサブタイプの ときに真を返します。 .. versionchanged:: 2.2 サブタイプを引数にとれるようになりました. @@ -31,30 +31,30 @@ .. cfunction:: int PyFloat_CheckExact(PyObject *p) - 引数が :ctype:`PyFloatObject` 型で、かつ :ctype:`PyFloatObject` 型のサブ タイプでないときに真を返します。 + 引数が :c:type:`PyFloatObject` 型で、かつ :c:type:`PyFloatObject` 型のサ ブタイプでないときに真を返します。 .. versionadded:: 2.2 .. cfunction:: PyObject* PyFloat_FromString(PyObject *str, char **pend) - *str* の文字列値をもとに :ctype:`PyFloatObject` オブジェクトを生成しま す。失敗すると *NULL* を返します。引数 + *str* の文字列値をもとに :c:type:`PyFloatObject` オブジェクトを生成しま す。失敗すると *NULL* を返します。引数 *pend* は無視されます。この引数は後方互換性のためだけに残されています。 .. cfunction:: PyObject* PyFloat_FromDouble(double v) - *v* から :ctype:`PyFloatObject` オブジェクトを生成して返します。失敗する と *NULL* を返します。 + *v* から :c:type:`PyFloatObject` オブジェクトを生成して返します。失敗す ると *NULL* を返します。 .. cfunction:: double PyFloat_AsDouble(PyObject *pyfloat) - *pyfloat* の指す値を、 C の :ctype:`double` 型表現で返します。 + *pyfloat* の指す値を、 C の :c:type:`double` 型表現で返します。 .. cfunction:: double PyFloat_AS_DOUBLE(PyObject *pyfloat) - *pyfloat* の指す値を、 C の :ctype:`double` 型表現で返しますが、エラーチ ェックを行いません。 + *pyfloat* の指す値を、 C の :c:type:`double` 型表現で返しますが、エラー チェックを行いません。 .. cfunction:: PyObject* PyFloat_GetInfo(void) @@ -67,14 +67,14 @@ .. cfunction:: double PyFloat_GetMax() - float の表現できる最大限解値 *DBL_MAX* を C の :ctype:`double` 型で返し ます。 + float の表現できる最大限解値 *DBL_MAX* を C の :c:type:`double` 型で返し ます。 .. versionadded:: 2.6 .. cfunction:: double PyFloat_GetMin() - float の正規化された最小の正の値 *DBL_MIN* を C の :ctype:`double` 型で 返します。 + float の正規化された最小の正の値 *DBL_MIN* を C の :c:type:`double` 型で 返します。 .. versionadded:: 2.6 ======================================= --- /c-api/function.rst Sun Nov 21 06:00:19 2010 +++ /c-api/function.rst Wed Mar 30 18:55:11 2011 @@ -19,13 +19,13 @@ .. index:: single: MethodType (in module types) - :ctype:`PyTypeObject` 型のインスタンスで、 Python の関数型を表します。こ れは Python プログラムに + :c:type:`PyTypeObject` 型のインスタンスで、 Python の関数型を表します。 これは Python プログラムに ``types.FunctionType`` として公開されます。 .. cfunction:: int PyFunction_Check(PyObject *o) - *o* が関数オブジェクト (:cdata:`PyFunction_Type` を持っている) なら true を返します。引数は *NULL* + *o* が関数オブジェクト (:c:data:`PyFunction_Type` を持っている) なら true を返します。引数は *NULL* であってはいけません。 ======================================= --- /c-api/gcsupport.rst Wed Dec 1 22:58:33 2010 +++ /c-api/gcsupport.rst Wed Mar 30 18:55:11 2011 @@ -25,35 +25,35 @@ コンテナ型のコンストラクタは以下の二つの規則に適合しなければなりません: -#. オブジェクトのメモリは :cfunc:`PyObject_GC_New` また は :cfunc:`PyObject_GC_NewVar` +#. オブジェクトのメモリは :c:func:`PyObject_GC_New` また は :c:func:`PyObject_GC_NewVar` で確保しなければなりません。 -#. 一度他のコンテナへの参照が入るかもしれないフィールドが全て初期化された ら、 :cfunc:`PyObject_GC_Track` を呼び出さねば +#. 一度他のコンテナへの参照が入るかもしれないフィールドが全て初期化された ら、 :c:func:`PyObject_GC_Track` を呼び出さねば なりません。 .. cfunction:: TYPE* PyObject_GC_New(TYPE, PyTypeObject *type) - :cfunc:`PyObject_New` に似ていますが、 :const:`Py_TPFLAGS_HAVE_GC` + :c:func:`PyObject_New` に似ていますが、 :const:`Py_TPFLAGS_HAVE_GC` のセットされたコンテナオブジェクト用です。 .. cfunction:: TYPE* PyObject_GC_NewVar(TYPE, PyTypeObject *type, Py_ssize_t size) - :cfunc:`PyObject_NewVar` に似ていますが、 :const:`Py_TPFLAGS_HAVE_GC` + :c:func:`PyObject_NewVar` に似ていますが、 :const:`Py_TPFLAGS_HAVE_GC` のセットされたコンテナオブジェクト用です。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: TYPE* PyObject_GC_Resize(TYPE, PyVarObject *op, Py_ssize_t newsize) - :cfunc:`PyObject_NewVar` が確保したオブジェクトのメモリをリサイズしま す。 + :c:func:`PyObject_NewVar` が確保したオブジェクトのメモリをリサイズしま す。 リサイズされたオブジェクトを返します。失敗すると *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *newsize* の型に :ctype:`int` を利用していました。 + この関数は以前は *newsize* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: void PyObject_GC_Track(PyObject *op) @@ -66,23 +66,23 @@ .. cfunction:: void _PyObject_GC_TRACK(PyObject *op) - :cfunc:`PyObject_GC_Track` のマクロ版です。拡張モジュールに使ってはなり ません。 + :c:func:`PyObject_GC_Track` のマクロ版です。拡張モジュールに使ってはなり ません。 同様に、オブジェクトのメモリ解放関数も以下の二つの規則に適合しなければなり ません: -#. 他のコンテナを参照しているフィールドを無効化する前 に、 :cfunc:`PyObject_GC_UnTrack` を呼び出さねばなりません。 - -#. オブジェクトのメモリは :cfunc:`PyObject_GC_Del` で解放しなければなりませ ん。 +#. 他のコンテナを参照しているフィールドを無効化する前 に、 :c:func:`PyObject_GC_UnTrack` を呼び出さねばなりません。 + +#. オブジェクトのメモリは :c:func:`PyObject_GC_Del` で解放しなければなりま せん。 .. cfunction:: void PyObject_GC_Del(void *op) - :cfunc:`PyObject_GC_New` や :cfunc:`PyObject_GC_NewVar` を使って確保され たメモリを解放します。 + :c:func:`PyObject_GC_New` や :c:func:`PyObject_GC_NewVar` を使って確保さ れたメモリを解放します。 .. cfunction:: void PyObject_GC_UnTrack(void *op) - ガベージコレクタが追跡しているコンテナオブジェクトの集合からオブジェク ト *op* を除去します。 :cfunc:`PyObject_GC_Track` + ガベージコレクタが追跡しているコンテナオブジェクトの集合からオブジェク ト *op* を除去します。 :c:func:`PyObject_GC_Track` を呼び出して、除去したオブジェクトを再度追跡対象セットに追加できるので注 意してください。メモリ解放関数 (deallocator, :attr:`tp_dealloc` ハンドラ) は、 :attr:`tp_traverse` ハンドラが使用して いるフィールドのいずれかが無効化されるよりも 以前にオブジェクトに対して呼び出されていなければなりません。 @@ -90,7 +90,7 @@ .. cfunction:: void _PyObject_GC_UNTRACK(PyObject *op) - :cfunc:`PyObject_GC_UnTrack` のマクロ版です。拡張モジュールに使ってはな りません。 + :c:func:`PyObject_GC_UnTrack` のマクロ版です。拡張モジュールに使ってはな りません。 :attr:`tp_traverse` ハンドラは以下の型を持つ関数を引数の一つとしてとります: @@ -111,7 +111,7 @@ コンテナに入っている各オブジェクトと、このハンドラに渡された *arg* の値 です。 *visit* 関数は *NULL* オブジェクトを引数に 渡して呼び出してはなりません。 *visit* が非ゼロの値を返す場合、エラーが 発生し、戻り値をそのまま返すようににしなければなりません。 -:attr:`tp_traverse` ハンドラの作成を単純化するため、 :cfunc:`Py_VISIT` +:attr:`tp_traverse` ハンドラの作成を単純化するため、 :c:func:`Py_VISIT` マクロが提供されています。このマクロを使うには、 :attr:`tp_traverse` の実装 で、引数を *visit* および *arg* という名前にしておかねばなりません: @@ -131,7 +131,7 @@ .. versionadded:: 2.4 -:attr:`tp_clear` ハンドラは :ctype:`inquiry` 型にするか、オブジェクトが変更 不能の場合には *NULL* +:attr:`tp_clear` ハンドラは :c:type:`inquiry` 型にするか、オブジェクトが変 更不能の場合には *NULL* にしなければなりません。 *NULL* if the object is immutable. @@ -139,6 +139,6 @@ 循環参照を形成しているとおぼしき参照群を放棄します。変更不可能なオブジェ クトは循環参照を直接形成することが決してない ので、この関数を定義する必要はありません。このメソッドを呼び出した後でも オブジェクトは有効なままでなければならないので注意してください (参照に対して - :cfunc:`Py_DECREF` を呼ぶだけにしないでください)。ガベージコレクタは、オ ブジェクトが + :c:func:`Py_DECREF` を呼ぶだけにしないでください)。ガベージコレクタは、 オブジェクトが 循環参照を形成していることを検出した際にこのメソッドを呼び出します。 ======================================= --- /c-api/gen.rst Sun Nov 21 06:00:19 2010 +++ /c-api/gen.rst Wed Mar 30 18:55:11 2011 @@ -6,7 +6,7 @@ ------------------------ ジェネレータ (generator) オブジェクトは、 Python がジェネレータ型イテレータ を実装するために使っているオブジェクトです。 -ジェネレータオブジェクトは、通常、 :cfunc:`PyGen_New` で明示的に生成される ことはなく、値を逐次生成するような関数に対してイテレーションを +ジェネレータオブジェクトは、通常、 :c:func:`PyGen_New` で明示的に生成される ことはなく、値を逐次生成するような関数に対してイテレーションを 行うときに生成されます。 .. % Generator Objects ======================================= --- /c-api/import.rst Sun Nov 28 17:59:04 2010 +++ /c-api/import.rst Wed Mar 30 18:55:11 2011 @@ -13,7 +13,7 @@ single: package variable; __all__ single: modules (in module sys) - この関数は下で述べる :cfunc:`PyImport_ImportModuleEx` を単純化したインタ フェースで、 *globals* および + この関数は下で述べる :c:func:`PyImport_ImportModuleEx` を単純化したイン タフェースで、 *globals* および *locals* 引数を *NULL* のままにし、 *level* を 0 にしたものです。 *name* 引数にドットが含まれる場合 (あるパッケージのサブモジュールを指定 している場合)、 *fromlist* 引数がリスト ``['*']`` に追加され、戻り値がモジュールを含む @@ -33,11 +33,11 @@ .. cfunction:: PyObject* PyImport_ImportModuleNoBlock(const char *name) - このバージョンの :cfunc:`PyImport_ImportModule` はブロックしません。 + このバージョンの :c:func:`PyImport_ImportModule` はブロックしません。 関数を実行するために他のモジュールをインポートするC関数から使われること を意図しています。 インポート処理は他のスレッドがインポートロックを持っている場合はブロック します。 この関数はブロックしません。まず sys.modules からモジュールのフェッチを 試み、 - 失敗したら、ロックが取られていなければ :cfunc:`PyImport_ImportModule` を 実行します。 + 失敗したら、ロックが取られていなければ :c:func:`PyImport_ImportModule` を実行します。 ロックが取られていた場合は :exc:`ImportError` を発生させます。 .. versionadded:: 2.6 @@ -58,7 +58,7 @@ import に失敗した場合、不完全なモジュールを除去するようになりました. .. versionchanged:: 2.6 - この関数は :cfunc:`PyImport_ImportModuleLevel` のエイリアスです。 + この関数は :c:func:`PyImport_ImportModuleLevel` のエイリアスです。 level には相対インポートを意味する -1 が渡されます。 @@ -108,7 +108,7 @@ .. note:: この関数はモジュールの import やロードを行いません; モジュールがまだ ロードされていなければ、空のモジュールオブジェクトを得ることになります。 - :cfunc:`PyImport_ImportModule` やその別形式を使ってモジュールを import してください。ドット名表記で + :c:func:`PyImport_ImportModule` やその別形式を使ってモジュールを import してください。ドット名表記で 指定した *name* が存在しない場合、パッケージ構造は作成されません。 @@ -119,7 +119,7 @@ モジュール名 (``package.module`` 形式でもかまいません) および Python の バイトコードファイルや組み込み関数 :func:`compile` で得られたコードオブジェクトを元にモジュールをロードし ます。モジュールオブジェクトへの新たな参照を返します。失敗した 場合には例外をセットし、 *NULL* を返します。Python 2.4 以前では、失敗し た場合でもモジュールは生成されていることがありました。 Python - 2.4 以降では、たとえ :cfunc:`PyImport_ExecCodeModule` の処理に入った時 に *name* が :attr:``sys.modules`` + 2.4 以降では、たとえ :c:func:`PyImport_ExecCodeModule` の処理に入った時 に *name* が :attr:``sys.modules`` に入っていたとしても、 import に失敗したモジュール は :attr:``sys.modules`` に残りません。初期化の不完全なモジュールを :attr:``sys.modules`` に残すのは危険であり、そのようなモジュールを import するコードにとっては、モジュールの状態がわからない (モジュール作者の意図から外れた壊れた状態かもしれない) からです。 @@ -127,7 +127,7 @@ モジュールの :attr:`__file__` 属性が、コードオブジェクト の :cmember:`co_filename` に設定されます。 この関数は、すでに import されているモジュールの場合には再ロードを行いま す。意図的にモジュールの再ロードを行う方法は - :cfunc:`PyImport_ReloadModule` を参照してください。 + :c:func:`PyImport_ReloadModule` を参照してください。 *name* が ``package.module`` 形式のドット名表記であった場合、まだ作成さ れていないパッケージ構造はその作成されないままになります。 @@ -137,9 +137,9 @@ .. cfunction:: PyObject* PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname) - Like :cfunc:`PyImport_ExecCodeModule`, but the :attr:`__file__` attribute of + Like :c:func:`PyImport_ExecCodeModule`, but the :attr:`__file__` attribute of the module object is set to *pathname* if it is non-``NULL``. - :cfunc:`PyImport_ExecCodeModule` に似ていますが、 *pathname* が ``NULL`` で無い場合、 + :c:func:`PyImport_ExecCodeModule` に似ていますが、 *pathname* が ``NULL`` で無い場合、 モジュールオブジェクトの :attr:`__file__` 属性に設定します。 @@ -197,7 +197,7 @@ *name* という名前のフリーズ (freeze) されたモジュールをロードします。成 功すると ``1`` を、モジュールが見つからなかった場合には ``0`` を、初期化が失敗した場合には例外をセットして ``-1`` を返します。 ロードに成功したモジュールにアクセスするには - :cfunc:`PyImport_ImportModule` を使ってください。 (Note この関数名はいさ さか誤称めいています --- この関数はすでに + :c:func:`PyImport_ImportModule` を使ってください。 (Note この関数名はい ささか誤称めいています --- この関数はすでに import 済みのモジュールをリロードしてしまいます。) @@ -218,23 +218,23 @@ .. cvar:: struct _frozen* PyImport_FrozenModules - このポインタは :ctype:`struct _frozen` のレコードからなり、終端の要素の メンバが *NULL* かゼロになっているような配列 + このポインタは :c:type:`struct _frozen` のレコードからなり、終端の要素の メンバが *NULL* かゼロになっているような配列 を指すよう初期化されます。フリーズされたモジュールを import するとき、こ のテーブルを検索します。サードパーティ製のコードから このポインタに仕掛けを講じて、動的に生成されたフリーズ化モジュールの集合 を提供するようにできます。 .. cfunction:: int PyImport_AppendInittab(char *name, void (*initfunc)(void)) - 既存の組み込みモジュールテーブルに単一のモジュールを追加します。この関数 は利便性を目的とした :cfunc:`PyImport_ExtendInittab` + 既存の組み込みモジュールテーブルに単一のモジュールを追加します。この関数 は利便性を目的とした :c:func:`PyImport_ExtendInittab` のラッパ関数で、テーブルが拡張できないときには ``-1`` を返します。新たな モジュールは *name* で import でき、最初に import を - 試みた際に呼び出される関数として *initfunc* を使いま す。 :cfunc:`Py_Initialize` よりも前に呼び出さねばなりません。 + 試みた際に呼び出される関数として *initfunc* を使いま す。 :c:func:`Py_Initialize` よりも前に呼び出さねばなりません。 .. ctype:: struct _inittab 組み込みモジュールリスト内の一つのエントリを記述している構造体です。リス ト内の各構造体には、インタプリタ内に組み込まれているモジュールの 名前と初期化関数が指定されています。 Python を埋め込むようなプログラム は、この構造体の配列と - :cfunc:`PyImport_ExtendInittab` を組み合わせて、追加の + :c:func:`PyImport_ExtendInittab` を組み合わせて、追加の 組み込みモジュールを提供できます。構造体は :file:`Include/import.h` で以 下のように定義されています:: struct _inittab { @@ -248,5 +248,5 @@ 組み込みモジュールのテーブルに一群のモジュールを追加します。配列 *newtab* は :attr:`name` フィールドが *NULL* になっている センチネル (sentinel) エントリで終端されていなければなりません; センチネ ル値を与えられなかった場合にはメモリ違反になるかもしれません。成功すると ``0`` を、内部テーブルを拡張するのに十分なメモリを確保できなかった場合に は ``-1`` を返します。操作が失敗した場合、 - モジュールは一切内部テーブルに追加されません。 :cfunc:`Py_Initialize` よ りも前に呼び出さねばなりません。 - + モジュールは一切内部テーブルに追加されません。 :c:func:`Py_Initialize` よりも前に呼び出さねばなりません。 + ======================================= --- /c-api/init.rst Thu Dec 2 21:42:29 2010 +++ /c-api/init.rst Wed Mar 30 18:55:11 2011 @@ -27,20 +27,20 @@ Python インタプリタを初期化します。Python の埋め込みを行う アプリケーションでは、他のあらゆる Python/C API を使用するよりも前に - この関数を呼び出さねばなりません; ただし、 :cfunc:`Py_SetProgramName`, - :cfunc:`PyEval_InitThreads`, :cfunc:`PyEval_ReleaseLock`, および - :cfunc:`PyEval_AcquireLock` は例外です。この関数はロード済みモジュールの + この関数を呼び出さねばなりません; ただし、 :c:func:`Py_SetProgramName`, + :c:func:`PyEval_InitThreads`, :c:func:`PyEval_ReleaseLock`, および + :c:func:`PyEval_AcquireLock` は例外です。この関数はロード済みモジュール の テーブル (``sys.modules``) を初期化し、基盤となるモジュール群、 :mod:`__builtin__`, :mod:`__main__` および :mod:`sys` を生成します。 また、モジュール検索パス (``sys.path``) も初期化します。 ``sys.argv`` - の設定は行いません; 設定するには、 :cfunc:`PySys_SetArgvEx` を使ってくだ さい。 - この関数を (:cfunc:`Py_Finalize` を呼ばずに) 再度呼び出しても何も行いま せん。 + の設定は行いません; 設定するには、 :c:func:`PySys_SetArgvEx` を使ってく ださい。 + この関数を (:c:func:`Py_Finalize` を呼ばずに) 再度呼び出しても何も行いま せん。 戻り値はありません; 初期化が失敗すれば、それは致命的なエラーです。 .. cfunction:: void Py_InitializeEx(int initsigs) - *initsigs* に1を指定すれば :cfunc:`Py_Initialize` と同じ処理を実 + *initsigs* に1を指定すれば :c:func:`Py_Initialize` と同じ処理を実 行しますが、Python埋め込みアプリケーションでは *initsigs* を0として 初期化時にシグナルハンドラの登録をスキップすることができます。 @@ -50,15 +50,15 @@ .. cfunction:: int Py_IsInitialized() Python インタプリタがすでに初期化済みの場合に真 (非ゼロ) を返し、そうで ない場合には偽 (ゼロ) - を返します。 :cfunc:`Py_Finalize` を呼び出すと、次 に :cfunc:`Py_Initialize` を呼び出すまでこの関数は偽を返します。 + を返します。 :c:func:`Py_Finalize` を呼び出すと、次 に :c:func:`Py_Initialize` を呼び出すまでこの関数は偽を返します。 .. cfunction:: void Py_Finalize() - :cfunc:`Py_Initialize` とそれ以後の Python/C API 関数で行った全ての初期 化処理を取り消し、最後の - :cfunc:`Py_Initialize` 呼び出し以後に Python インタプリタが生成した全て のサブインタプリタ (sub-interpreter, - 下記の :cfunc:`Py_NewInterpreter` を参照) を消去します。理想的な状況で は、この関数によって Python - インタプリタが確保したメモリは全て解放されます。この関数を (:cfunc:`Py_Initialize` を呼ばずに) 再度呼び出しても何も行いません。 + :c:func:`Py_Initialize` とそれ以後の Python/C API 関数で行った全ての初期 化処理を取り消し、最後の + :c:func:`Py_Initialize` 呼び出し以後に Python インタプリタが生成した全 てのサブインタプリタ (sub-interpreter, + 下記の :c:func:`Py_NewInterpreter` を参照) を消去します。理想的な状況で は、この関数によって Python + インタプリタが確保したメモリは全て解放されます。この関数を (:c:func:`Py_Initialize` を呼ばずに) 再度呼び出しても何も行いません。 戻り値はありません; 終了処理中のエラーは無視されます。 この関数が提供されている理由はいくつかあります。Python の埋め込みを行っ ているアプリケーションでは、アプリケーションを再起動することなく Python @@ -71,7 +71,7 @@ 動的にロードされるようになっている拡張モジュールが Python によってロード されていた場合、アンロードされません。Python が確保した メモリがわずかながら解放されないかもしれません (メモリリークを発見した ら、どうか報告してください)。オブジェクト間の循環参照に 捕捉されているメモリは解放されないことがあります。拡張モジュールが確保し たメモリは解放されないことがあります。拡張モジュールによっては、初期化ルーチ ンを 2 - 度以上呼び出すと正しく動作しないことがあります; こうした状況 は、 :cfunc:`Py_Initialize` や :cfunc:`Py_Finalize` + 度以上呼び出すと正しく動作しないことがあります; こうした状況 は、 :c:func:`Py_Initialize` や :c:func:`Py_Finalize` を 2 度以上呼び出すと起こり得ます。 @@ -91,7 +91,7 @@ (``sys.modules``) およびモジュール検索パス (``sys.path``) もサブインタ プリタ 毎に別個のものになります。新たなサブインタプリタ環境には ``sys.argv`` 変 数がありません。また、サブインタプリタは新たな標準 I/O ストリーム ``sys.stdin``, ``sys.stdout`` および ``sys.stderr`` を持ちます (とはい え、これらのストリームは根底にある C - ライブラリの同じ :ctype:`FILE` 構造体を参照しています)。 + ライブラリの同じ :c:type:`FILE` 構造体を参照しています)。 戻り値は、新たなサブインタプリタが生成したスレッド状態 (thread state) オ ブジェクトのうち、最初のものを指しています。 このスレッド状態が現在のスレッド状態 (current thread state) になります。 実際のスレッドが生成されるわけではないので注意してください; @@ -108,7 +108,7 @@ 拡張モジュールは以下のような形で (サブ) インタプリタ間で共有されます: あ る特定の拡張モジュールを最初に import すると、 モジュールを通常通りに初期化し、そのモジュールの辞書の (浅い) コピーをし まい込んでおきます。他の (サブ) インタプリタが同じ拡張モジュールを import すると、新たなモジュールを初期化し、先ほどのコピーの内容で辞書の 値を埋めます; 拡張モジュールの ``init`` - 関数は呼び出されません。この挙動は、 :cfunc:`Py_Finalize` およ び :cfunc:`Py_Initialize` を呼び出して + 関数は呼び出されません。この挙動は、 :c:func:`Py_Finalize` およ び :c:func:`Py_Initialize` を呼び出して インタプリタを完全に再初期化した後に拡張モジュールを import した際の挙動 とは異なるので注意してください; 再初期化後に import を 行うと、拡張モジュールの ``initmodule`` は再度 *呼び出され* ます。 @@ -123,8 +123,8 @@ 文は間違った (サブ) インタプリタのロード済みモジュール辞書に影響を及ぼす 場合があるからです (XXX この問題は 修正が難しいバグで、将来のリリースで解決される予定です) - この機能は PyObjC や ctypes のような、 :cfunc:`PyGILState_\*` API を利用 する - タイプの拡張モジュールと相性が悪いことにも注意してください。 (これ は、 :cfunc:`PyGILState_\*` 関数の動作特有の問題です) + この機能は PyObjC や ctypes のような、 :c:func:`PyGILState_\*` API を利 用する + タイプの拡張モジュールと相性が悪いことにも注意してください。 (これ は、 :c:func:`PyGILState_\*` 関数の動作特有の問題です) シンプルなことなら上手くいくかもしれませんが、いつ混乱させる動作をするか わかりません。 @@ -135,7 +135,7 @@ 指定されたスレッド状態 *tstate* で表現される (サブ) インタプリタを抹消し ます。 *tstate* は現在のスレッド状態でなければなりません。 下記のスレッド状態に関する議論を参照してください。関数呼び出しが戻ったと き、現在のスレッド状態は *NULL* になっています。 このインタプリタに関連付けられた全てのスレッド状態は抹消されます。 (この 関数を呼び出す前にはグローバルインタプリタロックを保持して - おかねばならず、ロックは関数が戻ったときも保持されています。 ) :cfunc:`Py_Finalize` は、その時点で + おかねばならず、ロックは関数が戻ったときも保持されています。 ) :c:func:`Py_Finalize` は、その時点で 明示的に抹消されていない全てのサブインタプリタを抹消します。 @@ -146,8 +146,8 @@ single: main() single: Py_GetPath() - この関数を呼び出すなら、最初に :cfunc:`Py_Initialize` を呼び出すよりも前 に呼び出さねばなりません。この関数はインタプリタに - プログラムの :cfunc:`main` 関数に指定した ``argv[0]`` 引数の値を教えま す。この引数値は、 :cfunc:`Py_GetPath` や、 + この関数を呼び出すなら、最初に :c:func:`Py_Initialize` を呼び出すよりも 前に呼び出さねばなりません。この関数はインタプリタに + プログラムの :c:func:`main` 関数に指定した ``argv[0]`` 引数の値を教えま す。この引数値は、 :c:func:`Py_GetPath` や、 以下に示すその他の関数が、インタプリタの実行可能形式から Python ランタイ ムライブラリへの相対パスを取得するために使われます。 デフォルトの値は ``'python'`` です。引数はゼロ終端されたキャラクタ文字列 で、静的な記憶領域に入っていなければならず、 その内容はプログラムの実行中に変更してはなりません。 Python インタプリタ 内のコードで、この記憶領域の内容を変更するものは一切ありません。 @@ -157,14 +157,14 @@ .. index:: single: Py_SetProgramName() - :cfunc:`Py_SetProgramName` で設定されたプログラム名か、デフォルトのプロ グラム名を返します。 + :c:func:`Py_SetProgramName` で設定されたプログラム名か、デフォルトのプロ グラム名を返します。 関数が返す文字列ポインタは静的な記憶領域を返します; 関数の呼び出し側はこ の値を変更できません。 .. cfunction:: char* Py_GetPrefix() プラットフォーム非依存のファイル群がインストールされている場所である *prefix* を返します。この値は - :cfunc:`Py_SetProgramName` でセットされたプログラム名やいくつかの環境変 数をもとに、数々の複雑な規則から導出されます; + :c:func:`Py_SetProgramName` でセットされたプログラム名やいくつかの環境変 数をもとに、数々の複雑な規則から導出されます; 例えば、プログラム名が ``'/usr/local/bin/python'`` の場合、prefix は ``'/usr/local'`` になります。 関数が返す文字列ポインタは静的な記憶領域を返します; 関数の呼び出し側はこ の値を変更できません。この値はトップレベルの :file:`Makefile` に指定されている変数 :makevar:`prefix` や、ビルド値 に :program:`configure` スクリプトに指定した @@ -175,7 +175,7 @@ .. cfunction:: char* Py_GetExecPrefix() プラットフォーム *依存* のファイルがインストールされている場所である *exec-prefix* を返します。 - この値は :cfunc:`Py_SetProgramName` でセットされたプログラム名やいくつか の環境変数をもとに、数々の複雑な規則から導出されます; + この値は :c:func:`Py_SetProgramName` でセットされたプログラム名やいくつ かの環境変数をもとに、数々の複雑な規則から導出されます; 例えば、プログラム名が ``'/usr/local/bin/python'`` の場合、exec-prefix は ``'/usr/local'`` になります。 関数が返す文字列ポインタは静的な記憶領域を返します; 関数の呼び出し側はこ の値を変更できません。この値はトップレベルの :file:`Makefile` に指定されている変数 :makevar:`exec_prefix` や、ビルド値 に :program:`configure` スクリプトに指定した @@ -206,7 +206,7 @@ single: executable (in module sys) Python 実行可能形式の完全なプログラム名を返します; この値はデフォルトの モジュール検索パスを - (前述の :cfunc:`Py_SetProgramName` で設定された) プログラム名から導出す る際に副作用的に計算されます。 + (前述の :c:func:`Py_SetProgramName` で設定された) プログラム名から導出 する際に副作用的に計算されます。 関数が返す文字列ポインタは静的な記憶領域を返します; 関数の呼び出し側はこ の値を変更できません。この値は Python コードからは ``sys.executable`` として利用できます。 Unixのみで有用です。 @@ -218,7 +218,7 @@ single: path (in module sys) デフォルトモジュール検索パスを返します; パスは (上の - :cfunc:`Py_SetProgramName` で設定された) プログラム名と、 + :c:func:`Py_SetProgramName` で設定された) プログラム名と、 いくつかの環境変数から計算されます。 戻り値となる文字列は、プラットフォーム依存のパスデリミタ文字で分割された 一連のディレクトリ名からなります。デリミタ文字は Unix と Mac OS X では @@ -302,12 +302,12 @@ single: argv (in module sys) *argc* および *argv* に基づいて :data:`sys.argv` を設定します。 - これらの引数はプログラムの :cfunc:`main` に渡した引数に似ていますが、 + これらの引数はプログラムの :c:func:`main` に渡した引数に似ていますが、 最初の要素が Python インタプリタの宿主となっている実行形式の名前ではな く、 実行されるスクリプト名を参照しなければならない点が違います。 実行するスクリプトがない場合、 *argv* の最初の要素は空文字列にしても かまいません。この関数が :data:`sys.argv` の初期化に失敗した場合、致命的 エラー - 条件を :cfunc:`Py_FatalError` でシグナルします。 + 条件を :c:func:`Py_FatalError` でシグナルします。 If *updatepath* is zero, this is all the function does. If *updatepath* is non-zero, the function also modifies :data:`sys.path` according to the @@ -329,7 +329,7 @@ `CVE-2008-5983 <http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-5983>`_ を参照してください。 - 2.6.6 より前のバージョンでは、 :cfunc:`PySys_SetArgv` を呼出たあとに + 2.6.6 より前のバージョンでは、 :c:func:`PySys_SetArgv` を呼出たあとに 同じ事を手動で :data:`sys.path` の先頭の要素を取り除くことで実現でき ます。 例えば、次のようにします。 :: @@ -344,7 +344,7 @@ .. cfunction:: void PySys_SetArgv(int argc, char **argv) - :cfunc:`PySys_SetArgv` の *updatepath* に 1 を設定したのと同じように動作 します。 + :c:func:`PySys_SetArgv` の *updatepath* に 1 を設定したのと同じように動 作します。 .. cfunction:: void Py_SetPythonHome(char *home) @@ -357,7 +357,7 @@ .. cfunction:: char* Py_GetPythonHome() - 前回の :cfunc:`Py_SetPythonHome` 呼び出しで設定されたデフォルト の "home" か、 + 前回の :c:func:`Py_SetPythonHome` 呼び出しで設定されたデフォルト の "home" か、 :envvar:`PYTHONHOME` 環境変数が設定されていればその値を返します。 @@ -392,9 +392,9 @@ single: PyThreadState Python インタプリタはスレッドごとに何らかの予約情報を持っておかねばなりませ ん ---- このため、Python は :ctype:`PyThreadState` と呼ばれるデータ構造を用いま す。 +--- このため、Python は :c:type:`PyThreadState` と呼ばれるデータ構造を用い ます。 とはいえ、グローバル変数はまだ一つだけ残っています: それは現在の -:ctype:`PyThreadState` 構造体を指すポインタです。 +:c:type:`PyThreadState` 構造体を指すポインタです。 スレッドローカルストレージ(:dfn:`thread-local-storage`, :dfn:`TLS`) が追加される前は、現在のスレッドの状態を明示的に操作しなければなりませんで した。 @@ -418,8 +418,8 @@ single: Py_BEGIN_ALLOW_THREADS single: Py_END_ALLOW_THREADS -:cmacro:`Py_BEGIN_ALLOW_THREADS` マクロは新たなブロック文を開始し、隠し -ローカル変数を宣言します; :cmacro:`Py_END_ALLOW_THREADS` +:c:macro:`Py_BEGIN_ALLOW_THREADS` マクロは新たなブロック文を開始し、隠し +ローカル変数を宣言します; :c:macro:`Py_END_ALLOW_THREADS` はブロック文を終了します。これらの二つのマクロを使うもうひとつの利点は、 Python をスレッドサポートなしでコンパイルしたとき、マクロの内容、 すなわちスレッド状態の退避とGIL操作が空になるという点です。 @@ -450,12 +450,12 @@ single: PyEval_ReleaseLock() single: PyEval_AcquireLock() -上の二つには微妙な違いがあります; とりわけ、 :cfunc:`PyEval_RestoreThread` -はグローバル変数 :cdata:`errno` の値を保存しておいて元に戻す点が異なりま す。 -というのは、ロック操作が :cdata:`errno` に何もしないという保証がないからで す。 -また、スレッドサポートが無効化されている場合、 :cfunc:`PyEval_SaveThread` および -:cfunc:`PyEval_RestoreThread` はGILを操作しません; この場合、 -:cfunc:`PyEval_ReleaseLock` および :cfunc:`PyEval_AcquireLock` は利用できま せん。 +上の二つには微妙な違いがあります; とりわけ、 :c:func:`PyEval_RestoreThread` +はグローバル変数 :c:data:`errno` の値を保存しておいて元に戻す点が異なりま す。 +というのは、ロック操作が :c:data:`errno` に何もしないという保証がないからで す。 +また、スレッドサポートが無効化されている場合、 :c:func:`PyEval_SaveThread` および +:c:func:`PyEval_RestoreThread` はGILを操作しません; この場合、 +:c:func:`PyEval_ReleaseLock` および :c:func:`PyEval_AcquireLock` は利用でき ません。 この仕様は、スレッドサポートを無効化してコンパイルされているインタプリタ が、 スレッドサポートが有効化された状態でコンパイルされている動的ロード拡張モジ ュールを ロードできるようにするためのものです。 @@ -479,7 +479,7 @@ インタプリタオブジェクトにアクセスできるという仮定の下では、C のスレッドか ら Python を呼び出す際の典型的な常套句は以下のようになります。 -バージョン 2.3 からは、上記の事を全て自動で行われて、スレッド は :cfunc:`PyGILState_\*` の恩恵に預かることができます。 C +バージョン 2.3 からは、上記の事を全て自動で行われて、スレッド は :c:func:`PyGILState_\*` の恩恵に預かることができます。 C のスレッドから Python を呼び出す典型的な方法は以下のとおりです。 :: PyGILState_STATE gstate; @@ -492,14 +492,14 @@ /* Release the thread. No Python API allowed beyond this point. */ PyGILState_Release(gstate); -:cfunc:`PyGILState_\*` 関数は、(:cfunc:`Py_Initialize` によって自動的に作ら れる) -グローバルインタプリタ一つだけが存在すると仮定する事に気をつけて下さい。 Python は (:cfunc:`Py_NewInterpreter` を使って) -追加のインタプリタを作成できることに変わりはありませんが、複数インタプリタ と :cfunc:`PyGILState_\*` API を混ぜて +:c:func:`PyGILState_\*` 関数は、(:c:func:`Py_Initialize` によって自動的に作 られる) +グローバルインタプリタ一つだけが存在すると仮定する事に気をつけて下さい。 Python は (:c:func:`Py_NewInterpreter` を使って) +追加のインタプリタを作成できることに変わりはありませんが、複数インタプリタ と :c:func:`PyGILState_\*` API を混ぜて 使うことはサポートされていません。 -注意しないといけないもう一つの重要な点は、 C の :cfunc:`fork` を呼び出した 時の +注意しないといけないもう一つの重要な点は、 C の :c:func:`fork` を呼び出した 時の 動作です。 -ほとんどの :cfunc:`fork` を持っているシステムでは、forkされたプロセスには forkを +ほとんどの :c:func:`fork` を持っているシステムでは、forkされたプロセスには forkを 実行したスレッドしか存在しません。 これは、別のスレッドに取得されたロックがずっと開放されないことを意味しま す。 Python は fork する前にロックを取得し、その後に fork を開放することで @@ -508,12 +508,12 @@ Python を拡張したり埋め込んだりしている場合、 Python に fork 前に取得したり fork 後に開放しなければならない追加の (Python 以外の)ロックを Python に教え る 手段がありません。 -Python と同じことを実現するには、 :cfunc:`posix_atfork` のようなOSの機能を +Python と同じことを実現するには、 :c:func:`posix_atfork` のようなOSの機能を 使う必要があります。 加えて、Python を拡張したり埋め込んだりしているときに、 :func:`os.fork` -を通してではなく直接 :cfunc:`fork` を呼び出すと、fork後に失われるスレッドに +を通してではなく直接 :c:func:`fork` を呼び出すと、fork後に失われるスレッド に 取得されていた Python の内部ロックのためにデッドロックが発生するかもしれま せん。 -:cfunc:`PyOS_AfterFork` は必要なロックのリセットを試みますが、いつでも +:c:func:`PyOS_AfterFork` は必要なロックのリセットを試みますが、いつでも それが可能とは限りません。 .. ctype:: PyInterpreterState @@ -528,7 +528,7 @@ .. ctype:: PyThreadState - 単一のスレッドの状態を表現する表現するデータ構造体です。データメン バ :ctype:`PyInterpreterState \*` :attr:`interp` + 単一のスレッドの状態を表現する表現するデータ構造体です。データメン バ :c:type:`PyInterpreterState \*` :attr:`interp` だけが公開されていて、スレッドのインタプリタ状態を指すポインタになってい ます。 @@ -539,12 +539,12 @@ single: PyEval_ReleaseThread() グローバルインタプリタロックを初期化し、獲得します。この関数は、主スレッ ドが第二のスレッドを生成する以前や、 - :cfunc:`PyEval_ReleaseLock` や ``PyEval_ReleaseThread(tstate)`` + :c:func:`PyEval_ReleaseLock` や ``PyEval_ReleaseThread(tstate)`` といった他のスレッド操作に入るよりも前に呼び出されるようにしておかなけれ ばなりません。 .. index:: single: Py_Initialize() - 二度目に呼び出すと何も行いません。この関数を :cfunc:`Py_Initialize` の前 に呼び出しても安全です。 + 二度目に呼び出すと何も行いません。この関数を :c:func:`Py_Initialize` の 前に呼び出しても安全です。 .. index:: module: thread @@ -557,7 +557,7 @@ 従って、この関数がGILを初期化すると、同時にロックを獲得するようになって います。Python の :mod:`thread` モジュールは、新たなスレッドを作成する前 に、 ロックが存在するか、あるいはまだ作成されていないかを調べ、 - :cfunc:`PyEval_InitThreads` を呼び出します。この関数から処理が戻った場 合、 + :c:func:`PyEval_InitThreads` を呼び出します。この関数から処理が戻った場 合、 ロックが作成作成され、呼び出し元スレッドがそのロックを獲得している事が 保証されています。 @@ -569,7 +569,7 @@ .. cfunction:: int PyEval_ThreadsInitialized() - :cfunc:`PyEval_InitThreads` をすでに呼び出している場合は真 (非ゼロ) + :c:func:`PyEval_InitThreads` をすでに呼び出している場合は真 (非ゼロ) を返します。この関数は、GILを獲得せずに呼び出すことができますので、 シングルスレッドで実行している場合にはロック関連のAPI呼び出しを避けるた めに 使うことができます。 @@ -625,27 +625,27 @@ .. cmacro:: Py_BEGIN_ALLOW_THREADS このマクロを展開すると ``{ PyThreadState *_save; _save = PyEval_SaveThread();`` になります。 - マクロに開き波括弧が入っていることに注意してください; この波括弧は後 で :cmacro:`Py_END_ALLOW_THREADS` + マクロに開き波括弧が入っていることに注意してください; この波括弧は後 で :c:macro:`Py_END_ALLOW_THREADS` マクロと対応させなければなりません。マクロについての詳しい議論は上記を参 照してください。コンパイル時にスレッドサポートが無効化されていると何も行いま せん。 .. cmacro:: Py_END_ALLOW_THREADS このマクロを展開すると ``PyEval_RestoreThread(_save); }`` になります。 - マクロに開き波括弧が入っていることに注意してください; この波括弧は事前 の :cmacro:`Py_BEGIN_ALLOW_THREADS` マクロと対応して + マクロに開き波括弧が入っていることに注意してください; この波括弧は事前 の :c:macro:`Py_BEGIN_ALLOW_THREADS` マクロと対応して いなければなりません。マクロについての詳しい議論は上記を参照してくださ い。コンパイル時にスレッドサポートが無効化されていると何も行いません。 .. cmacro:: Py_BLOCK_THREADS このマクロを展開すると ``PyEval_RestoreThread(_save);`` になります: - 閉じ波括弧のない :cmacro:`Py_END_ALLOW_THREADS` と同じです。コンパイル時 にスレッドサポートが無効化されていると何も行いません。 + 閉じ波括弧のない :c:macro:`Py_END_ALLOW_THREADS` と同じです。コンパイル 時にスレッドサポートが無効化されていると何も行いません。 .. cmacro:: Py_UNBLOCK_THREADS このマクロを展開すると ``_save = PyEval_SaveThread();`` になります: - 閉じ波括弧のない :cmacro:`Py_BEGIN_ALLOW_THREADS` と同じです。 + 閉じ波括弧のない :c:macro:`Py_BEGIN_ALLOW_THREADS` と同じです。 コンパイル時にスレッドサポートが無効化されていると何も行いません。 以下の全ての関数はコンパイル時にスレッドサポートが有効になっている時だけ @@ -670,7 +670,7 @@ インタプリタ状態オブジェクトを破壊します。 グローバルインタプリタロックを保持しておく必要はありません。 - インタプリタ状態は :cfunc:`PyInterpreterState_Clear` であらかじめリセッ トしておかなければなりません。 + インタプリタ状態は :c:func:`PyInterpreterState_Clear` であらかじめリセッ トしておかなければなりません。 .. cfunction:: PyThreadState* PyThreadState_New(PyInterpreterState *interp) @@ -690,7 +690,7 @@ スレッド状態オブジェクトを破壊します。 グローバルインタプリタロックを保持していなければなりません。 - スレッド状態は :cfunc:`PyThreadState_Clear` であらかじめリセットしておか なければなりません。 + スレッド状態は :c:func:`PyThreadState_Clear` であらかじめリセットしてお かなければなりません。 .. cfunction:: PyThreadState* PyThreadState_Get() @@ -733,19 +733,19 @@ Pythonの状態やGILに関わらず、実行中スレッドでPython C APIの呼 び出しが可能となるようにします。この関数はスレッド内で何度でも呼び出すこ とができますが、必ず全ての呼び出しに対応して - :cfunc:`PyGILState_Release` を呼び出す必要があります。 - - 通常、 :cfunc:`PyGILState_Ensure` 呼び出しと - :cfunc:`PyGILState_Release` 呼び出しの間でこれ以外のスレッド関連API + :c:func:`PyGILState_Release` を呼び出す必要があります。 + + 通常、 :c:func:`PyGILState_Ensure` 呼び出しと + :c:func:`PyGILState_Release` 呼び出しの間でこれ以外のスレッド関連API を使用することができますが、Release()の前にスレッド状態は復元されていな - ければなりません。通常の :cmacro:`Py_BEGIN_ALLOW_THREADS` マクロと - :cmacro:`Py_END_ALLOW_THREADS` も使用することができます。 - - 戻り値は :cfunc:`PyGILState_Ensure` 呼び出し時のスレッド状態を隠蔽し - た"ハンドル"で、 :cfunc:`PyGILState_Release` に渡してPythonを同じ状態 + ければなりません。通常の :c:macro:`Py_BEGIN_ALLOW_THREADS` マクロと + :c:macro:`Py_END_ALLOW_THREADS` も使用することができます。 + + 戻り値は :c:func:`PyGILState_Ensure` 呼び出し時のスレッド状態を隠蔽し + た"ハンドル"で、 :c:func:`PyGILState_Release` に渡してPythonを同じ状態 に保たなければなりません。再起呼び出しも可能ですが、ハンドルを共有するこ とは *できません* - - それぞれの :cfunc:`PyGILState_Ensure` 呼び出し - でハンドルを保存し、対応する :cfunc:`PyGILState_Release` 呼び出しで渡し てください。 + それぞれの :c:func:`PyGILState_Ensure` 呼び出し + でハンドルを保存し、対応する :c:func:`PyGILState_Release` 呼び出しで渡し てください。 関数から復帰したとき、実行中のスレッドはGILを所有しています。処理の失敗 は致命的なエラーです。 @@ -755,11 +755,11 @@ .. cfunction:: void PyGILState_Release(PyGILState_STATE) 獲得したすべてのリソースを開放します。この関数を呼び出すと、Pythonの状態 - は対応する :cfunc:`PyGILState_Ensure` を呼び出す前と同じとなります。(通 + は対応する :c:func:`PyGILState_Ensure` を呼び出す前と同じとなります。(通 常、この状態は呼び出し元でははわかりませんので、GILState APIを利用するよ うにしてください。） - :cfunc:`PyGILState_Ensure` を呼び出す場合は、必ず同一スレッド内で対 - 応する :cfunc:`PyGILState_Release` を呼び出してください。 + :c:func:`PyGILState_Ensure` を呼び出す場合は、必ず同一スレッド内で対 + 応する :c:func:`PyGILState_Release` を呼び出してください。 .. versionadded:: 2.3 @@ -784,7 +784,7 @@ .. ctype:: int (*Py_tracefunc)(PyObject *obj, PyFrameObject *frame, int what, PyObject *arg) - :cfunc:`PyEval_SetProfile` および :cfunc:`PyEval_SetTrace` + :c:func:`PyEval_SetProfile` および :c:func:`PyEval_SetTrace` を使って登録できるトレース関数の形式です。最初のパラメタはオブジェクト で、登録関数に *obj* として渡されます。 *frame* はイベントが属している実行フレームオブジェクトで、 *what* は定 数 :const:`PyTrace_CALL`, :const:`PyTrace_EXCEPTION`, :const:`PyTrace_LINE`, :const:`PyTrace_RETURN`, @@ -812,14 +812,14 @@ .. cvar:: int PyTrace_CALL - 関数やメソッドが新たに呼び出されたり、ジェネレータが新たなエントリの処理 に入ったことを報告する際の、 :ctype:`Py_tracefunc` の *what* + 関数やメソッドが新たに呼び出されたり、ジェネレータが新たなエントリの処理 に入ったことを報告する際の、 :c:type:`Py_tracefunc` の *what* の値です。イテレータやジェネレータ関数の生成は、対応するフレーム内の Python バイトコードに制御の委譲 (control transfer) が起こらないため報告されないので注意してください。 .. cvar:: int PyTrace_EXCEPTION - 例外が送出された際の :ctype:`Py_tracefunc` の *what* の値です。現在実行 されているフレームで例外がセットされ、何らかのバイトコードが + 例外が送出された際の :c:type:`Py_tracefunc` の *what* の値です。現在実行 されているフレームで例外がセットされ、何らかのバイトコードが 処理された後に、 *what* にこの値がセットされた状態でコールバック関数が呼 び出されます。 この結果、例外の伝播によって Python が呼び出しスタックを逆戻りする際に、 各フレームから処理が戻るごとにコールバック関数が呼び出されます。 @@ -833,22 +833,22 @@ .. cvar:: int PyTrace_RETURN - 関数呼び出しが例外の伝播なしに返るときに :ctype:`Py_tracefunc` 関数の *what* パラメタとして渡す値です。 + 関数呼び出しが例外の伝播なしに返るときに :c:type:`Py_tracefunc` 関数の *what* パラメタとして渡す値です。 .. cvar:: int PyTrace_C_CALL - C関数を呼び出す直前に :ctype:`Py_tracefunc` 関数の *what* パラメタとして 渡す値です。 + C関数を呼び出す直前に :c:type:`Py_tracefunc` 関数の *what* パラメタとし て渡す値です。 .. cvar:: int PyTrace_C_EXCEPTION - C関数が例外を送出したときに :ctype:`Py_tracefunc` 関数の *what* パラメタ として渡す値です。 + C関数が例外を送出したときに :c:type:`Py_tracefunc` 関数の *what* パラメ タとして渡す値です。 .. cvar:: int PyTrace_C_RETURN - C関数から戻るときに :ctype:`Py_tracefunc` 関数の *what* パラメタとして渡 す値です。 + C関数から戻るときに :c:type:`Py_tracefunc` 関数の *what* パラメタとして 渡す値です。 .. cfunction:: void PyEval_SetProfile(Py_tracefunc func, PyObject *obj) @@ -861,7 +861,7 @@ .. cfunction:: void PyEval_SetTrace(Py_tracefunc func, PyObject *obj) - トレース関数を *func* にセットします。 :cfunc:`PyEval_SetProfile` に似て いますが、トレース関数は + トレース関数を *func* にセットします。 :c:func:`PyEval_SetProfile` に似 ていますが、トレース関数は 行番号イベントを受け取る点が違います。 @@ -892,7 +892,7 @@ .. cfunction:: PyThreadState * PyInterpreterState_ThreadHead(PyInterpreterState *interp) - インタプリタ *interp* に関連付けられているスレッドからなるリストのうち、 先頭にある :ctype:`PyThreadState` + インタプリタ *interp* に関連付けられているスレッドからなるリストのうち、 先頭にある :c:type:`PyThreadState` オブジェクトを返します。 .. versionadded:: 2.2 @@ -900,7 +900,7 @@ .. cfunction:: PyThreadState* PyThreadState_Next(PyThreadState *tstate) - *tstate* と同じ :ctype:`PyInterpreterState` オブジェクトに属しているスレ ッド状態オブジェクトのうち、 *tstate* + *tstate* と同じ :c:type:`PyInterpreterState` オブジェクトに属しているス レッド状態オブジェクトのうち、 *tstate* の次にあるものを返します。 .. versionadded:: 2.2 ======================================= --- /c-api/int.rst Mon Nov 29 09:07:22 2010 +++ /c-api/int.rst Wed Mar 30 18:55:11 2011 @@ -10,20 +10,20 @@ .. ctype:: PyIntObject - この :ctype:`PyObject` のサブタイプは Python の整数型オブジェクトを表現 します。 + この :c:type:`PyObject` のサブタイプは Python の整数型オブジェクトを表現 します。 .. cvar:: PyTypeObject PyInt_Type .. index:: single: IntType (in modules types) - この :ctype:`PyTypeObject` のインスタンスは Python の (長整数でない)整数 型を表現します。これは + この :c:type:`PyTypeObject` のインスタンスは Python の (長整数でない)整 数型を表現します。これは ``int`` や ``types.IntType`` と同じオブジェクトです。 .. cfunction:: int PyInt_Check(PyObject *o) - *o* が :cdata:`PyInt_Type` 型か :cdata:`PyInt_Type` 型のサブタイプである ときに真を返します。 + *o* が :c:data:`PyInt_Type` 型か :c:data:`PyInt_Type` 型のサブタイプであ るときに真を返します。 .. versionchanged:: 2.2 サブタイプを引数にとれるようになりました. @@ -31,21 +31,21 @@ .. cfunction:: int PyInt_CheckExact(PyObject *o) - *o* が :cdata:`PyInt_Type` 型で、かつ :cdata:`PyInt_Type` 型のサブタイプ でないときに真を返します。 + *o* が :c:data:`PyInt_Type` 型で、かつ :c:data:`PyInt_Type` 型のサブタイ プでないときに真を返します。 .. versionadded:: 2.2 .. cfunction:: PyObject* PyInt_FromString(char *str, char **pend, int base) - *str* の文字列値に基づいて、新たな :ctype:`PyIntObject` また は :ctype:`PyLongObject` を返します。このとき + *str* の文字列値に基づいて、新たな :c:type:`PyIntObject` また は :c:type:`PyLongObject` を返します。このとき *base* を基数として文字列を解釈します。 *pend* が *NULL* でなければ、 ``*pend`` は *str* 中で 数が表現されている部分以後の先頭の文字のアドレスを指しています。 *base* が ``0`` ならば、 *str* の先頭の文字列に基づいて基数を決定します: もし *str* が ``'0x'`` または ``'0X'`` で始まっていれば、基数に 16 を使 います; *str* が ``'0'`` で始まっていれば、基数に 8 を使います; その他の場合には基数に 10 を使い ます。 *base* が ``0`` でなければ、 *base* は ``2`` 以上 ``36`` 以下の数でなければなりません。先頭に空白がある場合は無視され ます。数字が全くない場合、 :exc:`ValueError` が送出 - されます。使用しているマシンの :ctype:`long int` 型で表現し切れないくら い大きな数が文字列に入っており、オーバフロー警告が抑制されていれば、 - :ctype:`PyLongObject` を返します。オーバフロー警告が抑制されていなけれ ば、 *NULL* を返します。 + されます。使用しているマシンの :c:type:`long int` 型で表現し切れないくら い大きな数が文字列に入っており、オーバフロー警告が抑制されていれば、 + :c:type:`PyLongObject` を返します。オーバフロー警告が抑制されていなけれ ば、 *NULL* を返します。 .. cfunction:: PyObject* PyInt_FromLong(long ival) @@ -75,7 +75,7 @@ .. cfunction:: long PyInt_AsLong(PyObject *io) - オブジェクトがまだ :ctype:`PyIntObject` でなければまず型キャストを試み、 次にその値を返します。 + オブジェクトがまだ :c:type:`PyIntObject` でなければまず型キャストを試 み、次にその値を返します。 エラーが発生した場合、 ``-1`` が返されます。その時呼び出し側は、 ``PyErr_Occurred()`` を使って、エラーが発生したのか、 単に値が-1だったのかを判断するべきです。 @@ -87,23 +87,23 @@ .. cfunction:: unsigned long PyInt_AsUnsignedLongMask(PyObject *io) - オブジェクトがまだ :ctype:`PyIntObject` または :ctype:`PyLongObject` で - なければまず型キャストを試み、次にその値を :ctype:`unsigned long` 型で返 します。この関数はオーバフローをチェックしません。 + オブジェクトがまだ :c:type:`PyIntObject` または :c:type:`PyLongObject` で + なければまず型キャストを試み、次にその値を :c:type:`unsigned long` 型で 返します。この関数はオーバフローをチェックしません。 .. versionadded:: 2.3 .. cfunction:: unsigned PY_LONG_LONG PyInt_AsUnsignedLongLongMask(PyObject *io) - オブジェクトがまだ :ctype:`PyIntObject` または :ctype:`PyLongObject` で - なければまず型キャストを試み、次にその値を :ctype:`unsigned long long` 型で返します。オーバフローをチェックしません。 + オブジェクトがまだ :c:type:`PyIntObject` または :c:type:`PyLongObject` で + なければまず型キャストを試み、次にその値を :c:type:`unsigned long long` 型で返します。オーバフローをチェックしません。 .. versionadded:: 2.3 .. cfunction:: Py_ssize_t PyInt_AsSsize_t(PyObject *io) - オブジェクトがまだ :ctype:`PyIntObject` でなければまず型キャストを試み、 次にその値を :ctype:`Py_ssize_t` 型で返します。 + オブジェクトがまだ :c:type:`PyIntObject` でなければまず型キャストを試 み、次にその値を :c:type:`Py_ssize_t` 型で返します。 .. versionadded:: 2.5 ======================================= --- /c-api/intro.rst Sun Nov 28 08:22:38 2010 +++ /c-api/intro.rst Wed Mar 30 18:55:11 2011 @@ -86,15 +86,15 @@ .. index:: object: type -Python/C API 関数は、 :ctype:`PyObject\*` 型の一つ以上の引数と戻り値を持ち ます。 +Python/C API 関数は、 :c:type:`PyObject\*` 型の一つ以上の引数と戻り値を持ち ます。 この型は、任意の Python オブジェクトを表現する不透明 (opaque) なデータ型へ のポインタです。 Python 言語は、全ての Python オブジェクト型をほとんどの状況 (例えば代入、ス コープ規則 (scope rule)、引数渡し) で同様に扱います。ほとんど全ての Python オブジェク トはヒープ -(heap) 上に置かれます: このため、 :ctype:`PyObject` 型のオブジェクトは、 +(heap) 上に置かれます: このため、 :c:type:`PyObject` 型のオブジェクトは、 自動記憶 (automatic) としても静的記憶 (static) としても宣言できません。 -:ctype:`PyObject\*` 型のポインタ変数のみ宣言できます。唯一の例外は、型オブ ジェクト +:c:type:`PyObject\*` 型のポインタ変数のみ宣言できます。唯一の例外は、型オブ ジェクト です; 型オブジェクトはメモリ解放 (deallocate) してはならないので、 -通常は静的記憶の :ctype:`PyTypeObject` オブジェクトにします。 +通常は静的記憶の :c:type:`PyTypeObject` オブジェクトにします。 全ての Python オブジェクトには (Python 整数型ですら) 型 (:dfn:`type`) と参 照カウント (:dfn:`reference count`) があります。 @@ -121,9 +121,9 @@ single: Py_INCREF() single: Py_DECREF() -参照カウントは、常に明示的なやり方で操作されます。通常の方法で は、 :cfunc:`Py_INCREF` でオブジェクトの参照を 1 インクリメントし、 -:cfunc:`Py_DECREF` で 1 デクリメントします。 :cfunc:`Py_DECREF` マクロは、 incref よりもかなり -複雑です。というのは、 :cfunc:`Py_DECREF` マクロは参照カウントがゼロになっ たかどうかを調べて、なった場合にはオブジェクトのデアロケータ +参照カウントは、常に明示的なやり方で操作されます。通常の方法で は、 :c:func:`Py_INCREF` でオブジェクトの参照を 1 インクリメントし、 +:c:func:`Py_DECREF` で 1 デクリメントします。 :c:func:`Py_DECREF` マクロ は、incref よりもかなり +複雑です。というのは、 :c:func:`Py_DECREF` マクロは参照カウントがゼロになっ たかどうかを調べて、なった場合にはオブジェクトのデアロケータ (deallocator) を呼び出さなければならないからです。デアロケータとは、オブジ ェクトの型を定義している構造体内にある関数へのポインタです。 型固有のデアロケータは、その型が複合オブジェクト (compound object) 型である 場合には、オブジェクト内の他のオブジェクトに対する参照 カウントをデクリメントするよう気を配るとともに、その他の必要なファイナライ ズ (finalize) 処理を実行します。 @@ -142,11 +142,11 @@ しかしながら、よく陥る過ちとして、あるオブジェクトをリストから得たときに、 参照カウントをインクリメントせずにしばらく放っておく というのがあります。他の操作がオブジェクトをリストから除去してしまい、参照 カウントがデクリメントされてデアロケートされてしまうことが考えられます。 本当に危険なのは、まったく無害そうにみえる操作が、上記の動作を引き起こす何 らかの Python コードを呼び出しかねないということです; -:cfunc:`Py_DECREF` からユーザへ制御を戻せるようなコードパスが存在するため、 ほとんど全ての操作が潜在的に危険をはらむことになります。 +:c:func:`Py_DECREF` からユーザへ制御を戻せるようなコードパスが存在するた め、ほとんど全ての操作が潜在的に危険をはらむことになります。 安全に参照カウントを操作するアプローチは、汎用の操作 (関数名が ``PyObject_``, ``PyNumber_``, ``PySequence_``, および ``PyMapping_`` で始まる関数) の利用です。これらの操作は常に戻り値と なるオブジェクトの参照カウントをインクリメントします。 -ユーザには戻り値が不要になったら :cfunc:`Py_DECREF` を呼ぶ責任が残されてい ます; とはいえ、すぐにその習慣は身に付くでしょう。 +ユーザには戻り値が不要になったら :c:func:`Py_DECREF` を呼ぶ責任が残されてい ます; とはいえ、すぐにその習慣は身に付くでしょう。 .. _api-refcountdetails: @@ -156,9 +156,9 @@ Python/C API の各関数における参照カウントの振る舞いは、説明するには、 *参照 の所有権 (ownership of references)* という言葉でうまく説明できます。所有権は参照に対するもので、オブジェクトに 対するものではありません (オブジェクトは -誰にも所有されず、常に共有されています)。ある参照の "所有" は、その参照が必 要なくなった時点で :cfunc:`Py_DECREF` +誰にも所有されず、常に共有されています)。ある参照の "所有" は、その参照が必 要なくなった時点で :c:func:`Py_DECREF` を呼び出す役割を担うことを意味します。所有権は委譲でき、あるコードが委譲に よって所有権を得ると、今度はそのコードが参照が必要なくなった際に最終的に -:cfunc:`Py_DECREF` や :cfunc:`Py_XDECREF` を呼び出して decref する役割を担 います --- あるいは、その役割を +:c:func:`Py_DECREF` や :c:func:`Py_XDECREF` を呼び出して decref する役割を 担います --- あるいは、その役割を (通常はコードを呼び出した元に) 受け渡します。ある関数が、関数の呼び出し側に 対して参照の所有権を渡すと、呼び出し側は *新たな* 参照 (new reference) を得る、と言います。所有権が渡されない場合、呼び出し側は参照を *借りる* (borrow) といいます。借りた参照に対しては、何もする必要はありません。 @@ -172,8 +172,8 @@ single: PyList_SetItem() single: PyTuple_SetItem() -参照を盗み取る関数はほとんどありません; 例外としてよく知られているの は、 :cfunc:`PyList_SetItem` と -:cfunc:`PyTuple_SetItem` で、これらはシーケンスに入れる要素に対する参照を盗 み取ります (しかし、要素の +参照を盗み取る関数はほとんどありません; 例外としてよく知られているの は、 :c:func:`PyList_SetItem` と +:c:func:`PyTuple_SetItem` で、これらはシーケンスに入れる要素に対する参照を 盗み取ります (しかし、要素の 入る先のタプルやリストの参照は盗み取りません!)。これらの関数は、リストやタ プルの中に新たに作成されたオブジェクトを入れていく際の 常套的な書き方をしやすくするために、参照を盗み取るように設計されています; 例えば、 ``(1, 2, "three")`` というタプルを生成するコードは 以下のようになります (とりあえず例外処理のことは忘れておきます; もっとよい 書き方を後で示します):: @@ -185,8 +185,8 @@ PyTuple_SetItem(t, 1, PyInt_FromLong(2L)); PyTuple_SetItem(t, 2, PyString_FromString("three")); -ここで、 :cfunc:`PyInt_FromLong` は新しい参照を返し、すぐ に :cfunc:`PyTuple_SetItem` に盗まれます。 -参照が盗まれた後もそのオブジェクトを利用したい場合は、参照盗む関数を呼び出 す前に、 :cfunc:`Py_INCREF` を利用してもう一つの参照を取得 +ここで、 :c:func:`PyInt_FromLong` は新しい参照を返し、すぐ に :c:func:`PyTuple_SetItem` に盗まれます。 +参照が盗まれた後もそのオブジェクトを利用したい場合は、参照盗む関数を呼び出 す前に、 :c:func:`Py_INCREF` を利用してもう一つの参照を取得 してください。 .. % Here, \cfunction{PyInt_FromLong()} returns a new reference which is @@ -195,14 +195,14 @@ .. % use \cfunction{Py_INCREF()} to grab another reference before calling the .. % reference-stealing function. -ちなみに、 :cfunc:`PyTuple_SetItem` はタプルに値をセットするための *唯一の * 方法です; タプルは変更不能なデータ型なので、 -:cfunc:`PySequence_SetItem` や :cfunc:`PyObject_SetItem` -を使うと上の操作は拒否されてしまいます。自分でタプルの値を入れていくつもり なら、 :cfunc:`PyTuple_SetItem` だけしか使えません。 - -同じく、リストに値を入れていくコードは :cfunc:`PyList_New` と :cfunc:`PyList_SetItem` で書けます。 +ちなみに、 :c:func:`PyTuple_SetItem` はタプルに値をセットするための *唯一の * 方法です; タプルは変更不能なデータ型なので、 +:c:func:`PySequence_SetItem` や :c:func:`PyObject_SetItem` +を使うと上の操作は拒否されてしまいます。自分でタプルの値を入れていくつもり なら、 :c:func:`PyTuple_SetItem` だけしか使えません。 + +同じく、リストに値を入れていくコードは :c:func:`PyList_New` と :c:func:`PyList_SetItem` で書けます。 しかし実際には、タプルやリストを生成して値を入れる際には、上記のような方法 はほとんど使いません。 -より汎用性のある関数、 :cfunc:`Py_BuildValue` があり、ほとんどの主要なオブ ジェクトをフォーマット文字列 :dfn:`format +より汎用性のある関数、 :c:func:`Py_BuildValue` があり、ほとんどの主要なオブ ジェクトをフォーマット文字列 :dfn:`format string` の指定に基づいて C の値から生成できます。例えば、上の二種類のコード ブロックは、以下のように置き換えられます (エラーチェックにも配慮しています):: @@ -211,7 +211,7 @@ tuple = Py_BuildValue("(iis)", 1, 2, "three"); list = Py_BuildValue("[iis]", 1, 2, "three"); -自作の関数に渡す引数のように、単に参照を借りるだけの要素に対して は、 :cfunc:`PyObject_SetItem` とその仲間を +自作の関数に渡す引数のように、単に参照を借りるだけの要素に対して は、 :c:func:`PyObject_SetItem` とその仲間を 使うのがはるかに一般的です。その場合、参照カウントをインクリメントする必要 がなく、参照を引き渡せる ("参照を盗み取らせられる") ので、 参照カウントに関する動作はより健全になります。例えば、以下の関数は与えられ た要素をリスト中の全ての要素の値にセットします:: @@ -239,22 +239,22 @@ 関数の戻り値の場合には、状況は少し異なります。ほとんどの関数については、参 照を渡してもその参照に対する 所有権が変わることがない一方で、あるオブジェクトに対する参照を返すような多 くの関数は、参照に対する所有権を呼び出し側に与えます。理由は簡単です: 多くの場合、関数が返すオブジェクトはその場で (on the fly) 生成されるため、 呼び出し側が得る参照は生成された -オブジェクトに対する唯一の参照になるからです。従っ て、 :cfunc:`PyObject_GetItem` や -:cfunc:`PySequence_GetItem` のように、オブジェクトに対する参照を返す汎用の 関数は、常に新たな参照を返します (呼び出し側 +オブジェクトに対する唯一の参照になるからです。従っ て、 :c:func:`PyObject_GetItem` や +:c:func:`PySequence_GetItem` のように、オブジェクトに対する参照を返す汎用の 関数は、常に新たな参照を返します (呼び出し側 が参照の所有者になります)。 重要なのは、関数が返す参照の所有権を持てるかどうかは、どの関数を呼び出すか だけによる、と理解することです --- 関数呼び出し時の *お飾り* -(関数に引数として渡したオブジェクトの型) は *この問題には関係ありません!* 従って、 :cfunc:`PyList_GetItem` +(関数に引数として渡したオブジェクトの型) は *この問題には関係ありません!* 従って、 :c:func:`PyList_GetItem` を使ってリスト内の要素を得た場合には、参照の所有者にはなりません --- が、同 じ要素を同じリストから -:cfunc:`PySequence_GetItem` (図らずもこの関数は全く同じ引数をとります) を使 って取り出すと、返されたオブジェクト +:c:func:`PySequence_GetItem` (図らずもこの関数は全く同じ引数をとります) を 使って取り出すと、返されたオブジェクト に対する参照を得ます。 .. index:: single: PyList_GetItem() single: PySequence_GetItem() -以下は、整数からなるリストに対して各要素の合計を計算する関数をどのようにし て書けるかを示した例です; 一つは :cfunc:`PyList_GetItem` -を使っていて、もう一つは :cfunc:`PySequence_GetItem` を使っています。 :: +以下は、整数からなるリストに対して各要素の合計を計算する関数をどのようにし て書けるかを示した例です; 一つは :c:func:`PyList_GetItem` +を使っていて、もう一つは :c:func:`PySequence_GetItem` を使っています。 :: long sum_list(PyObject *list) @@ -306,8 +306,8 @@ 型 -- -Python/C API において重要な役割を持つデータ型は、 :ctype:`PyObject` 型の他 にもいくつかあります; ほとんどは -:ctype:`int`, :ctype:`long`, :ctype:`double`, および :ctype:`char\*` とい った、単なる C +Python/C API において重要な役割を持つデータ型は、 :c:type:`PyObject` 型の他 にもいくつかあります; ほとんどは +:c:type:`int`, :c:type:`long`, :c:type:`double`, および :c:type:`char\*` といった、単なる C のデータ型です。また、モジュールで公開している関数を列挙する際に用いられる 静的なテーブルや、新しいオブジェクト型におけるデータ属性を記述したり、 複素数の値を記述したりするために構造体をいくつか使っています。これらの型に ついては、その型を使う関数とともに説明してゆきます。 @@ -326,7 +326,7 @@ 説明がない限り例外を発行する可能性があります。一般的な話として、ある関数が 何らかのエラーに遭遇すると、関数は 例外を送出して、関数内における参照の所有権を全て放棄し、エラー指標 (error indicator) --- 通常は *NULL* または ``-1`` を返します。いくつかの関数ではブール型で真/偽を返し、偽はエラーを示します。 きわめて少数の関数では明確なエラー指標を返さなかったり、 -あいまいな戻り値を返したりするので、 :cfunc:`PyErr_Occurred` で明示的にエ ラーテストを行う必要があります。 +あいまいな戻り値を返したりするので、 :c:func:`PyErr_Occurred` で明示的にエ ラーテストを行う必要があります。 .. index:: single: PyErr_SetString() @@ -334,10 +334,10 @@ 例外時の状態情報 (exception state)は、スレッド単位に用意された記憶領域 (per-thread storage) 内で管理されます (この記憶領域は、スレッドを使わないアプリケーションではグローバルな記憶領域 と同じです)。一つのスレッドは二つの状態のどちらか: -例外が発生したか、まだ発生していないか、をとります。関 数 :cfunc:`PyErr_Occurred` を使うと、この状態を調べられます: +例外が発生したか、まだ発生していないか、をとります。関 数 :c:func:`PyErr_Occurred` を使うと、この状態を調べられます: この関数は例外が発生した際にはその例外型オブジェクトに対する借用参照 (borrowed reference) を返し、そうでないときには *NULL* -を返します。例外状態を設定する関数は数多くありま す: :cfunc:`PyErr_SetString` はもっともよく知られている -(が、もっとも汎用性のない) 例外を設定するための関数 で、 :cfunc:`PyErr_Clear` は例外状態情報を消し去る関数です。 +を返します。例外状態を設定する関数は数多くありま す: :c:func:`PyErr_SetString` はもっともよく知られている +(が、もっとも汎用性のない) 例外を設定するための関数 で、 :c:func:`PyErr_Clear` は例外状態情報を消し去る関数です。 .. index:: single: exc_type (in module sys) @@ -368,7 +368,7 @@ .. index:: single: sum_sequence() -例外を検出して渡す例は、上の :cfunc:`sum_sequence` で示しています。偶然に も、この例ではエラーを検出した際に何ら参照を放棄する必要が +例外を検出して渡す例は、上の :c:func:`sum_sequence` で示しています。偶然に も、この例ではエラーを検出した際に何ら参照を放棄する必要が ありません。以下の関数の例では、エラーに対する後始末について示しています。 まず、どうして Python で書くのが好きか思い出してもらうために、等価な Python コードを示します:: @@ -434,9 +434,9 @@ single: Py_XDECREF() なんとこの例は C で ``goto`` 文を使うお勧めの方法まで示していますね! この例 では、特定の例外を処理するために -:cfunc:`PyErr_ExceptionMatches` および :cfunc:`PyErr_Clear` をどう使うかを -示しています。また、所有権を持っている参照で、値が *NULL* になるかもしれな いものを捨てるために :cfunc:`Py_XDECREF` -をどう使うかも示しています (関数名に ``'X'`` が付いていることに注意してくだ さい; :cfunc:`Py_DECREF` は *NULL* +:c:func:`PyErr_ExceptionMatches` および :c:func:`PyErr_Clear` をどう使うか を +示しています。また、所有権を持っている参照で、値が *NULL* になるかもしれな いものを捨てるために :c:func:`Py_XDECREF` +をどう使うかも示しています (関数名に ``'X'`` が付いていることに注意してくだ さい; :c:func:`Py_DECREF` は *NULL* 参照に出くわすとクラッシュします)。正しく動作させるためには、所有権を持つ参 照を保持するための変数を *NULL* で初期化することが重要です; 同様に、 あらかじめ戻り値を定義する際には値を ``-1`` (失敗) で初期化しておいて、最後 の関数呼び出しまでうまくいった場合にのみ ``0`` (成功) に設定します。 @@ -460,24 +460,24 @@ triple: module; search; path single: path (in module sys) -基本的な初期化処理を行う関数は :cfunc:`Py_Initialize` です。この関数はロー ド済みのモジュールからなるテーブルを作成し、 +基本的な初期化処理を行う関数は :c:func:`Py_Initialize` です。この関数はロー ド済みのモジュールからなるテーブルを作成し、 土台となるモジュール :mod:`__builtin__`, :mod:`__main__`, :mod:`sys`, およ び :mod:`exceptions` を作成します。また、モジュール検索パス (``sys.path``) の初期化も行います。 .. index:: single: PySys_SetArgv() -:cfunc:`Py_Initialize` の中では、 "スクリプトへの引数リスト" (script argument list, ``sys.argv`` -のこと) を設定しません。この変数が後に実行される Python コード中で必要な ら、 :cfunc:`Py_Initialize` に続いて +:c:func:`Py_Initialize` の中では、 "スクリプトへの引数リスト" (script argument list, ``sys.argv`` +のこと) を設定しません。この変数が後に実行される Python コード中で必要な ら、 :c:func:`Py_Initialize` に続いて ``PySys_SetArgv(argc, argv)`` を呼び出して明示的に設定しなければなりませ ん。 -ほとんどのシステムでは (特に Unix と Windows は、詳細がわずかに異なりはしま すが)、 :cfunc:`Py_Initialize` は標準の +ほとんどのシステムでは (特に Unix と Windows は、詳細がわずかに異なりはしま すが)、 :c:func:`Py_Initialize` は標準の Python インタプリタ実行形式の場所に対する推定結果に基づいて、 Python のライ ブラリが Python インタプリタ実行形式からの相対パスで 見つかるという仮定の下にモジュール検索パスを計算します。とりわけこの検索で は、シェルコマンド検索パス (環境変数 :envvar:`PATH`) 上に見つかった :file:`python` という名前の実行ファイルの置かれているディレ クトリの親ディレクトリからの相対で、 :file:`lib/python{X.Y}` という名前のディレクトリを探します。 例えば、 Python 実行形式が :file:`/usr/local/bin/python` で見つかった -とすると、 :cfunc:`Py_Initialize` はライブラリ が :file:`/usr/local/lib/python{X.Y}` +とすると、 :c:func:`Py_Initialize` はライブラリ が :file:`/usr/local/lib/python{X.Y}` にあるものと仮定します。 (実際には、このパスは "フォールバック (fallback)" のライブラリ位置でもあり、 :file:`python` が :envvar:`PATH` 上にない場合に使われます。) ユーザは :envvar:`PYTHONHOME` を 設定することでこの動作をオーバライド したり、 :envvar:`PYTHONPATH` を設定して追加のディレクトリを標準モジュール 検索パスの前に挿入したりできます。 @@ -489,21 +489,21 @@ single: Py_GetExecPrefix() single: Py_GetProgramFullPath() -埋め込みを行うアプリケーションでは、 :cfunc:`Py_Initialize` を呼び出す *前 に* +埋め込みを行うアプリケーションでは、 :c:func:`Py_Initialize` を呼び出す *前 に* ``Py_SetProgramName(file)`` を呼び出すことで、上記の検索を操作できます。こ の埋め込みアプリケーションでの設定は依然として :envvar:`PYTHONHOME` でオーバライドでき、標準のモジュール検索パスの前には 以前として :envvar:`PYTHONPATH` -が挿入されるので注意してください。アプリケーションでモジュール検索パスを完 全に制御したいのなら、独自に :cfunc:`Py_GetPath`, -:cfunc:`Py_GetPrefix`, :cfunc:`Py_GetExecPrefix`, および -:cfunc:`Py_GetProgramFullPath` の実装を提供しなければなりません (これらは 全て +が挿入されるので注意してください。アプリケーションでモジュール検索パスを完 全に制御したいのなら、独自に :c:func:`Py_GetPath`, +:c:func:`Py_GetPrefix`, :c:func:`Py_GetExecPrefix`, および +:c:func:`Py_GetProgramFullPath` の実装を提供しなければなりません (これらは 全て :file:`Modules/getpath.c` で定義されています)。 .. index:: single: Py_IsInitialized() たまに、 Python を "初期化しない" ようにしたいことがあります。例えば、ある アプリケーションでは実行を最初からやりなおし (start over) -させる (:cfunc:`Py_Initialize` をもう一度呼び出させる) ようにしたいかもしれ ません。あるいは、アプリケーションが Python -を一旦使い終えて、Python が確保したメモリを解放できるようにしたいかもしれま せん。 :cfunc:`Py_Finalize` を使うと、こうした処理を -実現できます。また、関数 :cfunc:`Py_IsInitialized` は、Python が現在初期化 済みの状態にある場合に真を返します。 -これらの関数についてのさらなる情報は、後の章で説明しま す。 :cfunc:`Py_Finalize` がPythonインタプリタに確保された全てのメモリを +させる (:c:func:`Py_Initialize` をもう一度呼び出させる) ようにしたいかもし れません。あるいは、アプリケーションが Python +を一旦使い終えて、Python が確保したメモリを解放できるようにしたいかもしれま せん。 :c:func:`Py_Finalize` を使うと、こうした処理を +実現できます。また、関数 :c:func:`Py_IsInitialized` は、Python が現在初期 化済みの状態にある場合に真を返します。 +これらの関数についてのさらなる情報は、後の章で説明しま す。 :c:func:`Py_Finalize` がPythonインタプリタに確保された全てのメモリを *開放するわけではない* ことに注意してください。例えば、拡張モジュールによっ て確保されたメモリは、現在のところ開放する事ができません。 @@ -519,10 +519,10 @@ :file:`Misc/SpecialBuilds.txt` にあります。参照カウントのトレース、メモリア ロケータのデバッグ、インタプリタのメインループの 低レベルプロファイリングが利用可能です。よく使われるビルドについてのみ、こ の節の残りの部分で説明します。 -インタプリタを :cmacro:`Py_DEBUG` マクロを有効にしてコンパイルすると、一般 的に「デバッグビルド」といわれるPythonができます。 +インタプリタを :c:macro:`Py_DEBUG` マクロを有効にしてコンパイルすると、一般 的に「デバッグビルド」といわれるPythonができます。 Unix では、 :file:`configure` コマンドに :option:`--with-pydebug` を追加す ることで、 -:cmacro:`Py_DEBUG` が有効になります。その場合、暗黙的にPython専用ではな い :cmacro:`_DEBUG` も有効になります。 -Unix ビルドでは、 :cmacro:`Py_DEBUG` が有効な場合、コンパイラの最適化が無効 になります。 +:c:macro:`Py_DEBUG` が有効になります。その場合、暗黙的にPython専用ではな い :c:macro:`_DEBUG` も有効になります。 +Unix ビルドでは、 :c:macro:`Py_DEBUG` が有効な場合、コンパイラの最適化が無 効になります。 あとで説明する参照カウントデバッグの他に、以下の追加チェックも有効になりま す。 @@ -547,10 +547,10 @@ ここで言及されていない追加チェックもあるでしょう。 -:cmacro:`Py_TRACE_REFS` を宣言すると、参照トレースが有効になります。全て の :ctype:`PyObject` +:c:macro:`Py_TRACE_REFS` を宣言すると、参照トレースが有効になります。全て の :c:type:`PyObject` に二つのフィールドを追加することで、使用中のオブジェクトの循環二重連結リス トが管理されます。全ての割り当て(allocation)がトレースされます。 終了時に、全ての残っているオブジェクトが表示されます。 (インタラクティブ モードでは、インタプリタによる文の実行のたびに表示されます) -:cmacro:`Py_TRACE_REFS` は :cmacro:`Py_DEBUG` によって暗黙的に有効になりま す。 +:c:macro:`Py_TRACE_REFS` は :c:macro:`Py_DEBUG` によって暗黙的に有効になり ます。 より詳しい情報については、Pythonのソース配布(source distribution)の中 の :file:`Misc/SpecialBuilds.txt` を参照してください。 ======================================= --- /c-api/iterator.rst Sun Nov 21 06:00:19 2010 +++ /c-api/iterator.rst Wed Mar 30 18:55:11 2011 @@ -12,7 +12,7 @@ .. cvar:: PyTypeObject PySeqIter_Type - :cfunc:`PySeqIter_New` や、組み込みシーケンス型に対して 1 引数形式の組み 込み関数 :func:`iter` を呼び出したときに + :c:func:`PySeqIter_New` や、組み込みシーケンス型に対して 1 引数形式の組 み込み関数 :func:`iter` を呼び出したときに 返される、イテレータオブジェクトの型オブジェクトです。 .. versionadded:: 2.2 @@ -20,7 +20,7 @@ .. cfunction:: int PySeqIter_Check(op) - :cdata:`PySeqIter_Type` の型が *op* のときに真を返します。 + :c:data:`PySeqIter_Type` の型が *op* のときに真を返します。 .. versionadded:: 2.2 @@ -35,7 +35,7 @@ .. cvar:: PyTypeObject PyCallIter_Type - :cfunc:`PyCallIter_New` や、組み込み関数 :func:`iter` の 2 引数形式が返 すイテレータオブジェクトの型オブジェクトです。 + :c:func:`PyCallIter_New` や、組み込み関数 :func:`iter` の 2 引数形式が返 すイテレータオブジェクトの型オブジェクトです。 :func:`iter` built-in function. .. versionadded:: 2.2 @@ -43,7 +43,7 @@ .. cfunction:: int PyCallIter_Check(op) - :cdata:`PyCallIter_Type` の型が *op* のときに真を返します。 + :c:data:`PyCallIter_Type` の型が *op* のときに真を返します。 .. versionadded:: 2.2 ======================================= --- /c-api/list.rst Tue Nov 30 20:29:27 2010 +++ /c-api/list.rst Wed Mar 30 18:55:11 2011 @@ -10,18 +10,18 @@ .. ctype:: PyListObject - この :ctype:`PyObject` のサブタイプは Python のリストオブジェクトを表現 します。 + この :c:type:`PyObject` のサブタイプは Python のリストオブジェクトを表現 します。 .. cvar:: PyTypeObject PyList_Type - この :ctype:`PyTypeObject` のインスタンスは Python のタプル型を表現しま す。 + この :c:type:`PyTypeObject` のインスタンスは Python のタプル型を表現しま す。 これは Python レイヤにおける ``list`` と同じオブジェクトです。 .. cfunction:: int PyList_Check(PyObject *p) - 引数が :ctype:`PyListObject` である場合に真を返します。 + 引数が :c:type:`PyListObject` である場合に真を返します。 .. cfunction:: PyObject* PyList_New(Py_ssize_t len) @@ -31,11 +31,11 @@ .. note:: *len* が0より大きいとき、返されるリストオブジェクトの要素には ``NULL`` がセットされています。 - なので、 :cfunc:`PyList_SetItem` で本当にオブジェクトをセットする - までは、Pythonコードにこのオブジェクトを渡した り、 :cfunc:`PySequence_SetItem` のような抽象APIを利用してはいけません。 + なので、 :c:func:`PyList_SetItem` で本当にオブジェクトをセットする + までは、Pythonコードにこのオブジェクトを渡した り、 :c:func:`PySequence_SetItem` のような抽象APIを利用してはいけません。 .. versionchanged:: 2.5 - この関数は以前は *len* の型に :ctype:`int` を利用していました。 + この関数は以前は *len* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: Py_ssize_t PyList_Size(PyObject *list) @@ -45,15 +45,15 @@ リストオブジェクト *list* の長さを返します; リストオブジェクトにおける ``len(list)`` と同じです。 .. versionchanged:: 2.5 - これらの関数は以前は :ctype:`int` を返していました。 + これらの関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: Py_ssize_t PyList_GET_SIZE(PyObject *list) - マクロ形式でできた :cfunc:`PyList_Size` で、エラーチェックをしません。 + マクロ形式でできた :c:func:`PyList_Size` で、エラーチェックをしません。 .. versionchanged:: 2.5 - これらの関数は以前は :ctype:`int` を返していました。 + これらの関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyList_GetItem(PyObject *list, Py_ssize_t index) @@ -62,15 +62,15 @@ サポートされていません。 *pos* が範囲を超えている場合、 *NULL* を返し て :exc:`IndexError` 例外をセットします。 .. versionchanged:: 2.5 - この関数は以前は *index* の型に :ctype:`int` を利用していました。 + この関数は以前は *index* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyList_GET_ITEM(PyObject *list, Py_ssize_t i) - マクロ形式でできた :cfunc:`PyList_GetItem` で、エラーチェックをしませ ん。 + マクロ形式でできた :c:func:`PyList_GetItem` で、エラーチェックをしませ ん。 .. versionchanged:: 2.5 - この関数は以前は *i* の型に :ctype:`int` を利用していました。 + この関数は以前は *i* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PyList_SetItem(PyObject *list, Py_ssize_t index, PyObject *item) @@ -83,22 +83,22 @@ この関数は *item* への参照を "盗み取り" ます。また、変更先のインデク スにすでに別の要素が入っている場合、その要素に対する参照を放棄します。 .. versionchanged:: 2.5 - この関数は以前は *index* の型に :ctype:`int` を利用していました。 + この関数は以前は *index* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: void PyList_SET_ITEM(PyObject *list, Py_ssize_t i, PyObject *o) - :cfunc:`PyList_SetItem` をマクロによる実装で、エラーチェックを行いませ ん。 + :c:func:`PyList_SetItem` をマクロによる実装で、エラーチェックを行いませ ん。 このマクロは、新たなリストのまだ要素を入れたことのない位置に要素を入れる ときにのみ使います。 .. note:: - このマクロは *item* への参照を "盗み取り" ます。ま た、 :cfunc:`PyList_SetItem` と違って、要素の置き換えが生じても + このマクロは *item* への参照を "盗み取り" ます。ま た、 :c:func:`PyList_SetItem` と違って、要素の置き換えが生じても 置き換えられるオブジェクトへの参照を放棄 *しません* ; その結果、 *list* 中の位置 *i* で参照されていたオブジェクト がメモリリークを引き起こします。 .. versionchanged:: 2.5 - この関数は以前は *i* の型に :ctype:`int` を利用していました。 + この関数は以前は *i* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PyList_Insert(PyObject *list, Py_ssize_t index, PyObject *item) @@ -108,7 +108,7 @@ ``list.insert(index, item)`` に類似した機能です。 .. versionchanged:: 2.5 - この関数は以前は *index* の型に :ctype:`int` を利用していました。 + この関数は以前は *index* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PyList_Append(PyObject *list, PyObject *item) @@ -125,7 +125,7 @@ ただし、 Python のスライスにある負のインデックスはサポートされていませ ん。 .. versionchanged:: 2.5 - この関数は以前は *low*, *high* の型に :ctype:`int` を利用していまし た。 + この関数は以前は *low*, *high* の型に :c:type:`int` を利用していまし た。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PyList_SetSlice(PyObject *list, Py_ssize_t low, Py_ssize_t high, PyObject *itemlist) @@ -136,7 +136,7 @@ Python のスライスにある負のインデックスはサポートされていません。 .. versionchanged:: 2.5 - この関数は以前は *low*, *high* の型に :ctype:`int` を利用していまし た。 + この関数は以前は *low*, *high* の型に :c:type:`int` を利用していまし た。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PyList_Sort(PyObject *list) ======================================= --- /c-api/long.rst Mon Nov 29 09:07:22 2010 +++ /c-api/long.rst Wed Mar 30 18:55:11 2011 @@ -10,20 +10,20 @@ .. ctype:: PyLongObject - この :ctype:`PyObject` のサブタイプは長整数型を表現します。 + この :c:type:`PyObject` のサブタイプは長整数型を表現します。 .. cvar:: PyTypeObject PyLong_Type .. index:: single: LongType (in modules types) - この :ctype:`PyTypeObject` のインスタンスは Python 長整数型を表現しま す。これは + この :c:type:`PyTypeObject` のインスタンスは Python 長整数型を表現しま す。これは ``long`` や ``types.LongType`` と同じオブジェクトです。 .. cfunction:: int PyLong_Check(PyObject *p) - 引数が :ctype:`PyLongObject` か :ctype:`PyLongObject` のサブタイプのとき に真を返します。 + 引数が :c:type:`PyLongObject` か :c:type:`PyLongObject` のサブタイプのと きに真を返します。 .. versionchanged:: 2.2 サブタイプを引数にとれるようになりました. @@ -31,25 +31,25 @@ .. cfunction:: int PyLong_CheckExact(PyObject *p) - 引数が :ctype:`PyLongObject` 型で、かつ :ctype:`PyLongObject` 型のサブタ イプでないときに真を返します。 + 引数が :c:type:`PyLongObject` 型で、かつ :c:type:`PyLongObject` 型のサブ タイプでないときに真を返します。 .. versionadded:: 2.2 .. cfunction:: PyObject* PyLong_FromLong(long v) - *v* から新たな :ctype:`PyLongObject` オブジェクトを生成して返します。失 敗のときには *NULL* を返します。 + *v* から新たな :c:type:`PyLongObject` オブジェクトを生成して返します。失 敗のときには *NULL* を返します。 .. cfunction:: PyObject* PyLong_FromUnsignedLong(unsigned long v) - C の :ctype:`unsigned long` 型から新たな :ctype:`PyLongObject` オブジェ クトを生成して返します。 + C の :c:type:`unsigned long` 型から新たな :c:type:`PyLongObject` オブジ ェクトを生成して返します。 失敗のときには *NULL* を返します。 .. cfunction:: PyObject* PyLong_FromSsize_t(Py_ssize_t v) - C の :ctype:`Py_ssize_t` 型から新たな :ctype:`PyLongObject` オブジェクト を生成して返します。 + C の :c:type:`Py_ssize_t` 型から新たな :c:type:`PyLongObject` オブジェク トを生成して返します。 失敗のときには *NULL* を返します。 .. versionadded:: 2.6 @@ -57,7 +57,7 @@ .. cfunction:: PyObject* PyLong_FromSize_t(size_t v) - C の :ctype:`size_t` 型から新たな :ctype:`PyLongObject` オブジェクトを生 成して返します。 + C の :c:type:`size_t` 型から新たな :c:type:`PyLongObject` オブジェクトを 生成して返します。 失敗のときには *NULL* を返します。 .. versionadded:: 2.6 @@ -65,24 +65,24 @@ .. cfunction:: PyObject* PyLong_FromLongLong(PY_LONG_LONG v) - C の :ctype:`long long` 型から新たな :ctype:`PyLongObject` オブジェクト を生成して返します。失敗のときには + C の :c:type:`long long` 型から新たな :c:type:`PyLongObject` オブジェク トを生成して返します。失敗のときには *NULL* を返します。 .. cfunction:: PyObject* PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG v) - C の :ctype:`unsigned long long` 型から新たな :ctype:`PyLongObject` + C の :c:type:`unsigned long long` 型から新たな :c:type:`PyLongObject` オブジェクトを生成して返します。失敗のときには *NULL* を返します。 .. cfunction:: PyObject* PyLong_FromDouble(double v) - *v* の整数部から新たな :ctype:`PyLongObject` オブジェクトを生成して返し ます。失敗のときには *NULL* を返します。 + *v* の整数部から新たな :c:type:`PyLongObject` オブジェクトを生成して返し ます。失敗のときには *NULL* を返します。 .. cfunction:: PyObject* PyLong_FromString(char *str, char **pend, int base) - *str* の文字列値に基づいて、新たな :ctype:`PyLongObject` を返します。こ のとき *base* を基数として文字列を解釈します。 + *str* の文字列値に基づいて、新たな :c:type:`PyLongObject` を返します。こ のとき *base* を基数として文字列を解釈します。 *pend* が *NULL* でなければ、 ``*pend`` は *str* 中で数が表現されている 部分以後の先頭の文字のアドレスを指しています。 *base* が ``0`` ならば、 *str* の先頭の文字列に基づいて基数を決定しま す: もし *str* が ``'0x'`` または ``'0X'`` で始まっていれば、基数に 16 を使います; *str* が ``'0'`` で始まっていれ ば、基数に 8 を使います; その他の場合には基数に 10 を @@ -99,12 +99,12 @@ .. versionadded:: 1.6 .. versionchanged:: 2.5 - この関数は以前は *length* の型に :ctype:`int` を利用していました。 + この関数は以前は *length* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyLong_FromVoidPtr(void *p) - Python 整数型または長整数型をポインタ *p* から生成します。ポインタに入れ る値は :cfunc:`PyLong_AsVoidPtr` を使って + Python 整数型または長整数型をポインタ *p* から生成します。ポインタに入れ る値は :c:func:`PyLong_AsVoidPtr` を使って 得られるような値です。 .. versionadded:: 1.5.2 @@ -119,7 +119,7 @@ single: LONG_MAX single: OverflowError (built-in exception) - *pylong* の指す長整数値を、 C の :ctype:`long` 型表現で返します。 *pylong* が :const:`LONG_MAX` よりも + *pylong* の指す長整数値を、 C の :c:type:`long` 型表現で返します。 *pylong* が :const:`LONG_MAX` よりも 大きい場合、 :exc:`OverflowError` を送出し、 ``-1`` を返します。 @@ -129,7 +129,7 @@ single: PY_SSIZE_T_MAX single: OverflowError (built-in exception) - *pylong* の指す長整数値を、 C の :ctype:`Py_ssize_t` 型表現で返します。 + *pylong* の指す長整数値を、 C の :c:type:`Py_ssize_t` 型表現で返します。 *pylong* が :const:`PY_SSIZE_T_MAX` よりも大きい場合、 :exc:`OverflowError` を送出し、 ``-1`` を返します。 @@ -142,13 +142,13 @@ single: ULONG_MAX single: OverflowError (built-in exception) - *pylong* の指す長整数値を、 C の :ctype:`unsigned long` 型表現で返しま す。 *pylong* が + *pylong* の指す長整数値を、 C の :c:type:`unsigned long` 型表現で返しま す。 *pylong* が :const:`ULONG_MAX` よりも大きい場合、 :exc:`OverflowError` を送出しま す。 .. cfunction:: PY_LONG_LONG PyLong_AsLongLong(PyObject *pylong) - *pylong* の指す長整数値を、 C の :ctype:`long long` 型表現で返します。 *pylong* が :ctype:`long + *pylong* の指す長整数値を、 C の :c:type:`long long` 型表現で返します。 *pylong* が :c:type:`long long` で表せない場合、 :exc:`OverflowError` を送出します。 .. versionadded:: 2.2 @@ -156,8 +156,8 @@ .. cfunction:: unsigned PY_LONG_LONG PyLong_AsUnsignedLongLong(PyObject *pylong) - *pylong* の指す値を、 C の :ctype:`unsigned long long` 型表現で返しま す。 *pylong* が - :ctype:`unsigned long long` で表せない場合、正の値な ら :exc:`OverflowError` を、負の値なら + *pylong* の指す値を、 C の :c:type:`unsigned long long` 型表現で返しま す。 *pylong* が + :c:type:`unsigned long long` で表せない場合、正の値な ら :exc:`OverflowError` を、負の値なら :exc:`TypeError` を送出します。 .. versionadded:: 2.2 @@ -165,29 +165,29 @@ .. cfunction:: unsigned long PyLong_AsUnsignedLongMask(PyObject *io) - Python 長整数値を、オーバフローチェックを行わずに C の :ctype:`unsigned long` 型表現で返します。 + Python 長整数値を、オーバフローチェックを行わずに C の :c:type:`unsigned long` 型表現で返します。 .. versionadded:: 2.3 .. cfunction:: unsigned PY_LONG_LONG PyLong_AsUnsignedLongLongMask(PyObject *io) - Python 長整数値を、オーバフローチェックを行わずに C の :ctype:`unsigned long long` 型表現で返します。 + Python 長整数値を、オーバフローチェックを行わずに C の :c:type:`unsigned long long` 型表現で返します。 .. versionadded:: 2.3 .. cfunction:: double PyLong_AsDouble(PyObject *pylong) - *pylong* の指す値を、 C の :ctype:`double` 型表現で返します。 *pylong* が :ctype:`double` + *pylong* の指す値を、 C の :c:type:`double` 型表現で返します。 *pylong* が :c:type:`double` を使って近似表現できない場合、 :exc:`OverflowError` 例外を送出して ``-1.0`` を返します。 .. cfunction:: void* PyLong_AsVoidPtr(PyObject *pylong) - Python の整数型か長整数型を指す *pylong* を、 C の :ctype:`void` ポイン タに変換します。 *pylong* を変換できなければ、 - :exc:`OverflowError` を送出します。この関数 は :cfunc:`PyLong_FromVoidPtr` で値を生成するときに使うような - :ctype:`void` ポインタ型を生成できるだけです。 + Python の整数型か長整数型を指す *pylong* を、 C の :c:type:`void` ポイン タに変換します。 *pylong* を変換できなければ、 + :exc:`OverflowError` を送出します。この関数 は :c:func:`PyLong_FromVoidPtr` で値を生成するときに使うような + :c:type:`void` ポインタ型を生成できるだけです。 .. versionadded:: 1.5.2 ======================================= --- /c-api/mapping.rst Mon Nov 29 08:24:38 2010 +++ /c-api/mapping.rst Wed Mar 30 18:55:11 2011 @@ -20,7 +20,7 @@ Python の式 ``len(o)`` と同じになります。 .. versionchanged:: 2.5 - これらの関数は以前は :ctype:`int` を返していました。 + これらの関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PyMapping_DelItemString(PyObject *o, char *key) ======================================= --- /c-api/marshal.rst Sun Nov 28 18:28:47 2010 +++ /c-api/marshal.rst Wed Mar 30 18:55:11 2011 @@ -20,8 +20,8 @@ .. cfunction:: void PyMarshal_WriteLongToFile(long value, FILE *file, int version) - :ctype:`long` 型の整数値 *value* を *file* へ整列化します。この関数は *value* の下桁 32 ビットを書き込むだけです; - ネイティブの :ctype:`long` 型サイズには関知しません。 + :c:type:`long` 型の整数値 *value* を *file* へ整列化します。この関数は *value* の下桁 32 ビットを書き込むだけです; + ネイティブの :c:type:`long` 型サイズには関知しません。 .. versionchanged:: 2.4 ファイル形式を示す *version* が追加されました. @@ -52,26 +52,26 @@ .. cfunction:: long PyMarshal_ReadLongFromFile(FILE *file) - 読み出し用に開かれた :ctype:`FILE\*` 内のデータストリームから、 C の :ctype:`long` 型データを読み出して返します。 - この関数は、ネイティブの :ctype:`long` のサイズに関係なく、 32 ビットの 値だけを読み出せます。 + 読み出し用に開かれた :c:type:`FILE\*` 内のデータストリームから、 C の :c:type:`long` 型データを読み出して返します。 + この関数は、ネイティブの :c:type:`long` のサイズに関係なく、 32 ビットの 値だけを読み出せます。 .. cfunction:: int PyMarshal_ReadShortFromFile(FILE *file) - 読み出し用に開かれた :ctype:`FILE\*` 内のデータストリームから、 C の :ctype:`short` 型データを読み出して返します。 - この関数は、ネイティブの :ctype:`short` のサイズに関係なく、 16 ビットの 値だけを読み出せます。 + 読み出し用に開かれた :c:type:`FILE\*` 内のデータストリームから、 C の :c:type:`short` 型データを読み出して返します。 + この関数は、ネイティブの :c:type:`short` のサイズに関係なく、 16 ビット の値だけを読み出せます。 .. cfunction:: PyObject* PyMarshal_ReadObjectFromFile(FILE *file) - 読み出し用に開かれた :ctype:`FILE\*` 内のデータストリームから、 Python オブジェクトを読み出して返します。 + 読み出し用に開かれた :c:type:`FILE\*` 内のデータストリームから、 Python オブジェクトを読み出して返します。 エラーが生じた場合、適切な例外 (:exc:`EOFError` また は :exc:`TypeError`) を送出して *NULL* を返します。 .. cfunction:: PyObject* PyMarshal_ReadLastObjectFromFile(FILE *file) - 読み出し用に開かれた :ctype:`FILE\*` 内のデータストリームから、 Python オブジェクトを読み出して返します。 - :cfunc:`PyMarshal_ReadObjectFromFile` と違い、この関数はファイル中に後続 のオブジェクトが存在しないと仮定し、ファイルから + 読み出し用に開かれた :c:type:`FILE\*` 内のデータストリームから、 Python オブジェクトを読み出して返します。 + :c:func:`PyMarshal_ReadObjectFromFile` と違い、この関数はファイル中に後 続のオブジェクトが存在しないと仮定し、ファイルから メモリ上にファイルデータを一気にメモリにロードして、逆整列化機構がファイ ルから一バイトづつ読み出す代わりにメモリ上のデータを操作 できるようにします。対象のファイルから他に何も読み出さないと分かっている 場合にのみ、この関数を使ってください。エラーが生じた場合、適切な例外 (:exc:`EOFError` または :exc:`TypeError`) を送出して *NULL* を返します。 @@ -83,5 +83,5 @@ エラーが生じた場合、適切な例外 (:exc:`EOFError` また は :exc:`TypeError`) を送出して *NULL* を返します。 .. versionchanged:: 2.5 - 以前は *len* の型は :ctype:`int` でした。 + 以前は *len* の型は :c:type:`int` でした。 この変更により、64bitシステムをサポートするには対応する修正が必要にな ります。 ======================================= --- /c-api/memory.rst Wed Dec 1 08:46:42 2010 +++ /c-api/memory.rst Wed Mar 30 18:55:11 2011 @@ -40,7 +40,7 @@ single: free() メモリ管理の崩壊を避けるため、拡張モジュールの作者は決して Python オブジェ クトを C ライブラリが公開している関数: -:cfunc:`malloc` 、 :cfunc:`calloc` 、 :cfunc:`realloc` およ び :cfunc:`free` で操作しようとしては +:c:func:`malloc` 、 :c:func:`calloc` 、 :c:func:`realloc` およ び :c:func:`free` で操作しようとしては なりません。こうした関数を使うと、C のメモリ操作関数と Python メモリマネー ジャとの間で関数呼び出しが交錯します。 C のメモリ操作関数とPython メモリマネージャは異なるアルゴリズムで実装されていて、異なるヒープを操作す るため、呼び出しの交錯は致命的な結果を招きます。とはいえ、個別の目的のためな ら、 C ライブラリのメモリ操作関数を使って安全にメモリを確保したり解放したりでき ます。例えば、以下がそのような例です:: @@ -79,24 +79,24 @@ .. cfunction:: void* PyMem_Malloc(size_t n) - *n* バイトをメモリ確保し、確保されたメモリを指す :ctype:`void\*` 型のポ インタを返します。確保要求に失敗した場合には *NULL* を + *n* バイトをメモリ確保し、確保されたメモリを指す :c:type:`void\*` 型の ポインタを返します。確保要求に失敗した場合には *NULL* を 返します。 0 バイトをリクエストすると、可能ならば独立した非 *NULL* のポ インタを返します。このポインタは - :cfunc:`PyMem_Malloc(1)` を代わりに呼んだときのようなメモリ領域を指して います。 + :c:func:`PyMem_Malloc(1)` を代わりに呼んだときのようなメモリ領域を指し ています。 確保されたメモリ領域はいかなる初期化も行われていません。 .. cfunction:: void* PyMem_Realloc(void *p, size_t n) *p* が指しているメモリブロックを *n* バイトにサイズ変更します。メモリの 内容のうち、新旧のサイズのうち小さい方までの領域は変更されません。 *p* が - *NULL* ならば、この関数は :cfunc:`PyMem_Malloc(n)` と等価になります; そ れ以外の場合で、 *n* がゼロに等しければ、 + *NULL* ならば、この関数は :c:func:`PyMem_Malloc(n)` と等価になります; それ以外の場合で、 *n* がゼロに等しければ、 メモリブロックはサイズ変更されますが、解放されず、非 *NULL* のポインタを 返します。 *p* の値を *NULL* にしないのなら、以前呼び出した - :cfunc:`PyMem_Malloc` や :cfunc:`PyMem_Realloc` の返した値でなければな りません。 + :c:func:`PyMem_Malloc` や :c:func:`PyMem_Realloc` の返した値でなければ なりません。 .. cfunction:: void PyMem_Free(void *p) - *p* が指すメモリブロックを解放します。 *p* は以前呼び出し た :cfunc:`PyMem_Malloc` や - :cfunc:`PyMem_Realloc` の返した値でなければなりません。それ以外の場合 や、すでに :cfunc:`PyMem_Free(p)` を + *p* が指すメモリブロックを解放します。 *p* は以前呼び出し た :c:func:`PyMem_Malloc` や + :c:func:`PyMem_Realloc` の返した値でなければなりません。それ以外の場合 や、すでに :c:func:`PyMem_Free(p)` を 呼び出した後だった場合、未定義の動作になります。 *p* が *NULL* なら、何 も行いません。 以下に挙げる型対象のマクロは利便性のために提供されているものです。 *TYPE* は任意の C の型を表します。 @@ -104,15 +104,15 @@ .. cfunction:: TYPE* PyMem_New(TYPE, size_t n) - :cfunc:`PyMem_Malloc` と同じですが、 ``(n * sizeof(TYPE))`` バイトのメモ リを確保します。 - :ctype:`TYPE\*` に型キャストされたポインタを返します。メモリには何の初期 化も行われていません。 + :c:func:`PyMem_Malloc` と同じですが、 ``(n * sizeof(TYPE))`` バイトのメ モリを確保します。 + :c:type:`TYPE\*` に型キャストされたポインタを返します。メモリには何の初 期化も行われていません。 .. cfunction:: TYPE* PyMem_Resize(void *p, TYPE, size_t n) - :cfunc:`PyMem_Realloc` と同じですが、 ``(n * sizeof(TYPE))`` + :c:func:`PyMem_Realloc` と同じですが、 ``(n * sizeof(TYPE))`` バイトにサイズ変更されたメモリを確保します。 - :ctype:`TYPE\*` に型キャストされたポインタを返します。 + :c:type:`TYPE\*` に型キャストされたポインタを返します。 関数が終わったとき、 *p* は新しいメモリ領域のポインタか、失敗した場合は *NULL* になります。これは C プリプロセッサのマクロで、 p は常に上書きされます。エラーを処理するときにメモリを失う事を避けるには、 @@ -121,14 +121,14 @@ .. cfunction:: void PyMem_Del(void *p) - :cfunc:`PyMem_Free` と同じです。 + :c:func:`PyMem_Free` と同じです。 上記に加えて、C API 関数を介することなく Python メモリ操作関数を直接呼び出 すための以下のマクロセットが提供されています。 ただし、これらのマクロは Python バージョン間でのバイナリ互換性を保てず、そ れゆえに拡張モジュールでは撤廃されているので注意してください。 -:cfunc:`PyMem_MALLOC` 、 :cfunc:`PyMem_REALLOC` 、 :cfunc:`PyMem_FREE` 。 - -:cfunc:`PyMem_NEW` 、 :cfunc:`PyMem_RESIZE` 、 :cfunc:`PyMem_DEL` 。 +:c:func:`PyMem_MALLOC` 、 :c:func:`PyMem_REALLOC` 、 :c:func:`PyMem_FREE` 。 + +:c:func:`PyMem_NEW` 、 :c:func:`PyMem_RESIZE` 、 :c:func:`PyMem_DEL` 。 .. _memoryexamples: @@ -174,8 +174,8 @@ free(buf2); /* Right -- allocated via malloc() */ free(buf1); /* Fatal -- should be PyMem_Del() */ -素のメモリブロックを Python ヒープ上で操作する関数に加 え、 :cfunc:`PyObject_New` 、 -:cfunc:`PyObject_NewVar` 、および :cfunc:`PyObject_Del` を使うと、 Python におけるオブジェクトを +素のメモリブロックを Python ヒープ上で操作する関数に加 え、 :c:func:`PyObject_New` 、 +:c:func:`PyObject_NewVar` 、および :c:func:`PyObject_Del` を使うと、 Python におけるオブジェクトを メモリ確保したり解放したりできます。 これらの関数については、次章の C による新しいオブジェクト型の定義や実装に関 する記述の中で説明します。 ======================================= --- /c-api/method.rst Tue Nov 30 20:54:40 2010 +++ /c-api/method.rst Wed Mar 30 18:55:11 2011 @@ -14,13 +14,13 @@ .. index:: single: MethodType (in module types) - この :ctype:`PyTypeObject` のインスタンスは Python のメソッドオブジェク ト + この :c:type:`PyTypeObject` のインスタンスは Python のメソッドオブジェク ト 型を表現します。このオブジェクトは、 ``types.MethodType`` として Python プログラムに公開されています。 .. cfunction:: int PyMethod_Check(PyObject *o) - *o* がメソッドオブジェクト (:cdata:`PyMethod_Type` 型である) 場合に真を 返します。パラメタは *NULL* にできません。 + *o* がメソッドオブジェクト (:c:data:`PyMethod_Type` 型である) 場合に真を 返します。パラメタは *NULL* にできません。 .. cfunction:: PyObject* PyMethod_New(PyObject *func, PyObject *self, PyObject *class) @@ -39,7 +39,7 @@ .. cfunction:: PyObject* PyMethod_GET_CLASS(PyObject *meth) - :cfunc:`PyMethod_Class` をマクロで実装したバージョンで、エラーチェックを 行いません。 + :c:func:`PyMethod_Class` をマクロで実装したバージョンで、エラーチェック を行いません。 .. cfunction:: PyObject* PyMethod_Function(PyObject *meth) @@ -49,7 +49,7 @@ .. cfunction:: PyObject* PyMethod_GET_FUNCTION(PyObject *meth) - :cfunc:`PyMethod_Function` のマクロ版で、エラーチェックを行いません。 + :c:func:`PyMethod_Function` のマクロ版で、エラーチェックを行いません。 .. cfunction:: PyObject* PyMethod_Self(PyObject *meth) @@ -59,7 +59,7 @@ .. cfunction:: PyObject* PyMethod_GET_SELF(PyObject *meth) - :cfunc:`PyMethod_Self` のマクロ版で、エラーチェックを行いません。 + :c:func:`PyMethod_Self` のマクロ版で、エラーチェックを行いません。 .. cfunction:: int PyMethod_ClearFreeList() ======================================= --- /c-api/module.rst Wed Dec 1 02:12:03 2010 +++ /c-api/module.rst Wed Mar 30 18:55:11 2011 @@ -14,7 +14,7 @@ .. index:: single: ModuleType (in module types) - この :ctype:`PyTypeObject` のインスタンスは Python のモジュールオブジェ クト型を表現します。このオブジェクトは、Python + この :c:type:`PyTypeObject` のインスタンスは Python のモジュールオブジェ クト型を表現します。このオブジェクトは、Python プログラムには ``types.ModuleType`` として公開されています。 @@ -28,7 +28,7 @@ .. cfunction:: int PyModule_CheckExact(PyObject *p) - *o* がモジュールオブジェクトで、かつモジュールオブジェクトのサブタイプで ないときに真を返します。 :cdata:`PyModule_Type`. + *o* がモジュールオブジェクトで、かつモジュールオブジェクトのサブタイプで ないときに真を返します。 :c:data:`PyModule_Type`. .. versionadded:: 2.2 @@ -50,7 +50,7 @@ *module* の名前空間を実現する辞書オブジェクトを返します; このオブジェク トはモジュールオブジェクトの :attr:`__dict__` と同じです。この関数が失敗することはありません。 拡張モジュールでは、こ の関数で得たモジュールの :attr:`__dict__` - を直接いじるより、他の :cfunc:`PyModule_\*` および :cfunc:`PyObject_\*` 関数を使うよう勧めます。 + を直接いじるより、他の :c:func:`PyModule_\*` およ び :c:func:`PyObject_\*` 関数を使うよう勧めます。 .. cfunction:: char* PyModule_GetName(PyObject *module) ======================================= --- /c-api/none.rst Sun Nov 21 06:00:19 2010 +++ /c-api/none.rst Wed Mar 30 18:55:11 2011 @@ -7,9 +7,9 @@ .. index:: object: None -``None`` に対する :ctype:`PyTypeObject` は、 Python/C API では直接公開され ていないので注意してください。 +``None`` に対する :c:type:`PyTypeObject` は、 Python/C API では直接公開され ていないので注意してください。 ``None `` は単量子 (singleton) なので、オブジェクトのアイデンティティテス ト (C では `` ==``) を使うだけで十分だからです。 -同じ理由から、 :cfunc:`PyNone_Check` 関数はありません。 +同じ理由から、 :c:func:`PyNone_Check` 関数はありません。 .. cvar:: PyObject* Py_None @@ -20,5 +20,5 @@ .. cmacro:: Py_RETURN_NONE - C 関数から :cdata:`Py_None` を戻す操作を適切に行うためのマクロです。 - + C 関数から :c:data:`Py_None` を戻す操作を適切に行うためのマクロです。 + ======================================= --- /c-api/number.rst Mon Nov 29 07:31:48 2010 +++ /c-api/number.rst Wed Mar 30 18:55:11 2011 @@ -66,7 +66,7 @@ 組み込み関数 :func:`pow` を参照してください。失敗すると *NULL* を返しま す。 Python の式 ``pow(o1, o2, o3)`` と同じです。 - *o3* はオプションです。 *o3* を無視させたいなら、 :cdata:`Py_None` を入 れてください (*o3* + *o3* はオプションです。 *o3* を無視させたいなら、 :c:data:`Py_None` を入 れてください (*o3* に *NULL* を渡すと、不正なメモリアクセスを引き起こすことがあります)。 @@ -176,9 +176,9 @@ .. index:: builtin: pow 組み込み関数 :func:`pow` を参照してください。失敗すると *NULL* を返しま す。 *o1* が *in-place* - 演算をサポートする場合、in-place 演算を行います。この関数は *o3* が :cdata:`Py_None` の場合は Python 文 ``o1 + 演算をサポートする場合、in-place 演算を行います。この関数は *o3* が :c:data:`Py_None` の場合は Python 文 ``o1 **= o2 `` と同じで、それ以外の場合は `` pow(o1, o2, o3)`` の in-place 版 です。 *o3* を無視させたいなら、 - :cdata:`Py_None` を入れてください (*o3* に *NULL* を渡すと、不正なメモリ アクセスを引き起こすことがあります)。 + :c:data:`Py_None` を入れてください (*o3* に *NULL* を渡すと、不正なメモ リアクセスを引き起こすことがあります)。 .. cfunction:: PyObject* PyNumber_InPlaceLshift(PyObject *o1, PyObject *o2) @@ -217,7 +217,7 @@ .. index:: builtin: coerce - この関数は :ctype:`PyObject\*` 型の二つの変数のアドレスを引数にとりま す。 ``*p1`` と ``*p2`` + この関数は :c:type:`PyObject\*` 型の二つの変数のアドレスを引数にとりま す。 ``*p1`` と ``*p2`` が指すオブジェクトが同じ型の場合、それぞれの参照カウントをインクリメント して ``0`` (成功) を返します。 オブジェクトを変換して共通の数値型にできる場合、 ``*p1`` と ``*p2`` を変 換後の値に置き換えて (参照カウントを '新しく' して) 、 ``0`` を返します。変換が不可能な場合や、その他何らかのエラーが生じた 場合、 ``-1`` (失敗) を返し、参照カウントをインクリメントしません。 @@ -226,10 +226,10 @@ .. cfunction:: int PyNumber_CoerceEx(PyObject **p1, PyObject **p2) - This function is similar to :cfunc:`PyNumber_Coerce`, except that it returns + This function is similar to :c:func:`PyNumber_Coerce`, except that it returns ``1`` when the conversion is not possible and when no error is raised. Reference counts are still not increased in this case. - この関数は :cfunc:`PyNumber_Coerce` と似ていますが、 + この関数は :c:func:`PyNumber_Coerce` と似ていますが、 変換が失敗た場合にはエラーを発生させず、 ``-1`` を返します。 この場合、参照カウントはインクリメントされません。 @@ -273,7 +273,7 @@ ``'0x'`` の基数マーカーをつけます。 *base* が 2, 8, 10, 16 のいずれでも無い場合、フォーマットは x を基数とし て ``'x#num'`` となります。 - もし *n* が整数オブジェクトでない場合、まず :cfunc:`PyNumber_Index` を使 って + もし *n* が整数オブジェクトでない場合、まず :c:func:`PyNumber_Index` を 使って 変換されます。 .. versionadded:: 2.6 ======================================= --- /c-api/objbuffer.rst Mon Nov 29 08:31:05 2010 +++ /c-api/objbuffer.rst Wed Mar 30 18:55:11 2011 @@ -20,7 +20,7 @@ .. versionadded:: 1.6 .. versionchanged:: 2.5 - この関数は以前は *buffer_len* の型に :ctype:`int *` を利用していまし た。 + この関数は以前は *buffer_len* の型に :c:type:`int *` を利用していまし た。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PyObject_AsReadBuffer(PyObject *obj, const void **buffer, Py_ssize_t *buffer_len) @@ -32,7 +32,7 @@ .. versionadded:: 1.6 .. versionchanged:: 2.5 - この関数は以前は *buffer_len* の型に :ctype:`int *` を利用していまし た。 + この関数は以前は *buffer_len* の型に :c:type:`int *` を利用していまし た。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PyObject_CheckReadBuffer(PyObject *o) @@ -52,5 +52,5 @@ .. versionadded:: 1.6 .. versionchanged:: 2.5 - この関数は以前は *buffer_len* の型に :ctype:`int *` を利用していまし た。 + この関数は以前は *buffer_len* の型に :c:type:`int *` を利用していまし た。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 ======================================= --- /c-api/object.rst Mon Nov 29 16:27:12 2010 +++ /c-api/object.rst Wed Mar 30 18:55:11 2011 @@ -117,7 +117,7 @@ *o1* と *o2* の値を比較します。このとき *o1* が比較ルーチンを持っていれ ばそれを使い、なければ *o2* のルーチンを使います。比較結果は *result* に返されます。失敗すると ``-1`` を返します。 Python 文 ``result = cmp(o1, o2)`` - と同じです。成功すると比較結果を返します。エラーが生じた場合の戻り値は未 定義です; :cfunc:`PyErr_Occurred` を使ってエラー検出を + と同じです。成功すると比較結果を返します。エラーが生じた場合の戻り値は未 定義です; :c:func:`PyErr_Occurred` を使ってエラー検出を 行って下さい。Python 式 ``cmp(o1, o2)`` と同じです。 @@ -142,7 +142,7 @@ .. index:: builtin: bytes *o* オブジェクトの bytes 表現を計算します。 - 2.x では、単に :cfunc:`PyObject_Str` のエイリアスです。 + 2.x では、単に :c:func:`PyObject_Str` のエイリアスです。 .. cfunction:: PyObject* PyObject_Unicode(PyObject *o) @@ -157,7 +157,7 @@ *inst* が *cls* のインスタンスか、 *cls* のサブクラスのインスタンスの場 合に ``-1`` を返し、そうでなければ ``0`` を 返します。エラーの時には ``-1`` を返し、例外をセットします。 *cls* がク ラスオブジェクトではなく型オブジェクトの場合、 - :cfunc:`PyObject_IsInstance` は *inst* が *cls* であるときに ``1`` を返 します。 *cls* + :c:func:`PyObject_IsInstance` は *inst* が *cls* であるときに ``1`` を返 します。 *cls* をタプルで指定した場合、 *cls* に指定した全てのエントリについてチェック を行います。少なくとも一つのエントリに対するチェックが ``1`` を返せば結果は ``1`` になり、そうでなければ ``0`` になります。 *inst* が クラスインスタンスでなく、かつ *cls* が 型オブジェクトでもクラスオブジェクトでもタプルでもない場合、 *inst* に は :attr:`__class__` 属性がなくてはなりません --- @@ -172,7 +172,7 @@ :class:`B` がクラスオブジェクトの場合、 :class:`B` が :class:`A` のサブクラ スとなるのは、 :class:`B` が :class:`A` を直接的あるいは間接的に継承 (inherit) している場合です。両方が クラスオブジェクトでない場合、二つのオブジェクト間の クラス関係を決めるには、より汎用の機構を使います。 *B* が *A* のサブクラス であるか調べたとき、 *A* が *B* -と等しければ、 :cfunc:`PyObject_IsSubclass` は真を返します。 *A* および *B* が異なるオブジェクトなら、 *B* の +と等しければ、 :c:func:`PyObject_IsSubclass` は真を返します。 *A* および *B* が異なるオブジェクトなら、 *B* の :attr:`__bases__` 属性から深さ優先探索 (depth-first search)で *A* を探索し ます --- オブジェクトに :attr:`__bases__` があるだけで、この決定法を適用する条件を満 たしているとみなされます。 @@ -225,25 +225,25 @@ .. index:: builtin: apply 呼び出し可能な Python オブジェクト *callable_object* を可変数個の C 引数 とともに呼び出します。C 引数は - :cfunc:`Py_BuildValue` 形式のフォーマット文字列を使って記述します。 *format* + :c:func:`Py_BuildValue` 形式のフォーマット文字列を使って記述します。 *format* は *NULL* にしてもよく、与える引数がないことを表します。成功すると呼び出 し結果として得られたオブジェクトを返し、失敗すると *NULL* を返します。 Python の式 ``apply(callable, args)`` あるいは ``callable(*args)`` と同 じです。 - もしも、 :ctype:`PyObject \*` args だけを引数に渡す場合 は、 :cfunc:`PyObject_CallFunctionObjArgs` + もしも、 :c:type:`PyObject \*` args だけを引数に渡す場合 は、 :c:func:`PyObject_CallFunctionObjArgs` がより速い方法であることを覚えておいてください。 .. cfunction:: PyObject* PyObject_CallMethod(PyObject *o, char *method, char *format, ...) オブジェクト *o* の *method* という名前のメソッドを、可変数個の C 引数と ともに呼び出します。C 引数はタプルを生成するような - :cfunc:`Py_BuildValue` 形式のフォーマット文字列を使って記述します。 *format* + :c:func:`Py_BuildValue` 形式のフォーマット文字列を使って記述します。 *format* は *NULL* にしてもよく、与える引数がないことを表します。成功すると呼び出 し結果として得られたオブジェクトを返し、失敗すると *NULL* を返します。 - Python の式 ``o.method(args)`` と同じです。もしも、 :ctype:`PyObject \*` args - だけを引数に渡す場合は、 :cfunc:`PyObject_CallMethodObjArgs` がより速い 方法であることを覚えておいてください。 + Python の式 ``o.method(args)`` と同じです。もしも、 :c:type:`PyObject \*` args + だけを引数に渡す場合は、 :c:func:`PyObject_CallMethodObjArgs` がより速い 方法であることを覚えておいてください。 .. cfunction:: PyObject* PyObject_CallFunctionObjArgs(PyObject *callable, ..., NULL) - 呼び出し可能な Python オブジェクト *callable_object* を可変数個 の :ctype:`PyObject\*` + 呼び出し可能な Python オブジェクト *callable_object* を可変数個 の :c:type:`PyObject\*` 引数とともに呼び出します。引数列は末尾に *NULL* がついた可変数個のパラメ タとして与えます。 成功すると呼び出し結果として得られたオブジェクトを返し失敗すると *NULL* を返します。 @@ -253,7 +253,7 @@ .. cfunction:: PyObject* PyObject_CallMethodObjArgs(PyObject *o, PyObject *name, ..., NULL) オブジェクト *o* のメソッドを呼び出します、メソッド名は Python 文字列オ ブジェクト *name* で与えます。可変数個の - :ctype:`PyObject\*` 引数と共に呼び出されます. 引数列は末尾に *NULL* がつ いた可変数個のパラメタとして与えます。 + :c:type:`PyObject\*` 引数と共に呼び出されます. 引数列は末尾に *NULL* が ついた可変数個のパラメタとして与えます。 成功すると呼び出し結果として得られたオブジェクトを返し失敗すると *NULL* を返します。 .. versionadded:: 2.2 @@ -294,7 +294,7 @@ *o* が *NULL* でない場合、オブジェクト *o* のオブジェクト型に相当する型 オブジェクトを返します。失敗すると :exc:`SystemError` を送出して *NULL* を返します。 Python の式 ``type(o)`` と同じです。 こ の関数は戻り値の参照カウントをインクリメントします。 - 参照カウントのインクリメントが必要でない限り、広く使われてい て :ctype:`PyTypeObject\*` 型のポインタを返す表記法 + 参照カウントのインクリメントが必要でない限り、広く使われてい て :c:type:`PyTypeObject\*` 型のポインタを返す表記法 ``o->ob_type`` の代わりに使う理由は全くありません。 @@ -314,7 +314,7 @@ 返します。エラーが生じると ``-1`` を返します。 Python の式 ``len(o)`` と 同じです。 .. versionchanged:: 2.5 - これらの関数は以前は :ctype:`int` 型を返していました。 + これらの関数は以前は :c:type:`int` 型を返していました。 この変更により、 64bit システムを適切にサポートするためにはコードの修 正が必要になります。 .. cfunction:: PyObject* PyObject_GetItem(PyObject *o, PyObject *key) @@ -346,7 +346,7 @@ この関数は Python の式 ``dir(o)`` と同じで、オブジェクトの変数名に割り当 てている文字列からなるリスト (空の場合もあります) を返します。エラーの場合には *NULL* を返します。引数を *NULL* にすると、 Python における ``dir()`` と同様に、現在のローカルな名前を返します; この場合、アクティブな実行フ レームがなければ *NULL* を返しますが、 - :cfunc:`PyErr_Occurred` は偽を返します。 + :c:func:`PyErr_Occurred` は偽を返します。 .. cfunction:: PyObject* PyObject_GetIter(PyObject *o) ======================================= --- /c-api/refcounting.rst Sun Nov 28 08:49:35 2010 +++ /c-api/refcounting.rst Wed Mar 30 18:55:11 2011 @@ -13,7 +13,7 @@ .. cfunction:: void Py_INCREF(PyObject *o) オブジェクト *o* に対する参照カウントを一つ増やします。オブジェクトが *NULL* であってはいけません。それが *NULL* ではないと確信が持てないならば、 - :cfunc:`Py_XINCREF` を使ってください。 + :c:func:`Py_XINCREF` を使ってください。 .. cfunction:: void Py_XINCREF(PyObject *o) @@ -24,39 +24,39 @@ .. cfunction:: void Py_DECREF(PyObject *o) オブジェクト *o* に対する参照カウントを一つ減らします。オブジェクトが *NULL* であってはいけません。それが *NULL* ではないと確信が持てないならば、 - :cfunc:`Py_XDECREF` を使ってください。参照カウントがゼロになったら、 + :c:func:`Py_XDECREF` を使ってください。参照カウントがゼロになったら、 オブジェクトの型のメモリ解放関数(*NULL* であってはならない)が呼ばれま す。 .. warning:: (例えば :meth:`__del__` メソッドをもつクラスインスタンスがメモリ解放 されたときに)メモリ解放関数は任意のPythonコードを呼び出すことが できます。このようなコードでは例外は伝播しませんが、実行されたコード はすべてのPythonグローバル変数に自由にアクセスできます。 - これが意味するのは、 :cfunc:`Py_DECREF` が呼び出されるより前では、グ ローバル変数から到達可能などんなオブジェクトも一貫した状態に + これが意味するのは、 :c:func:`Py_DECREF` が呼び出されるより前では、グ ローバル変数から到達可能などんなオブジェクトも一貫した状態に あるべきであるということです。例えば、リストからオブジェクトを削除す るコードは削除するオブジェクト - への参照を一時変数にコピーし、リストデータ構造を更新し、それから一時 変数に対して :cfunc:`Py_DECREF` を呼び出すべきです。 + への参照を一時変数にコピーし、リストデータ構造を更新し、それから一時 変数に対して :c:func:`Py_DECREF` を呼び出すべきです。 .. cfunction:: void Py_XDECREF(PyObject *o) オブジェクト *o* への参照カウントを一つ減らします。オブジェクトは *NULL* でもかまいませんが、その場合マクロは何の影響も与えません。それ以外の - 場合、結果は :cfunc:`Py_DECREF` と同じです。また、注意すべきことも同じで す。 + 場合、結果は :c:func:`Py_DECREF` と同じです。また、注意すべきことも同じ です。 .. cfunction:: void Py_CLEAR(PyObject *o) *o* の参照カウントを減らします．オブジェクトは *NULL* でもよく，その場合 このマクロは何も行いません．オブジェクトが *NULL* でなければ，引数を - *NULL* にした :cfunc:`Py_DECREF` と同じ効果をもたらします．このマクロは 一時変数を使って，参照カウントをデクリメントする前に引数を - *NULL* にセットしてくれるので， :cfunc:`Py_DECREF` に使うときの警告を気 にしなくてすみます． + *NULL* にした :c:func:`Py_DECREF` と同じ効果をもたらします．このマクロは 一時変数を使って，参照カウントをデクリメントする前に引数を + *NULL* にセットしてくれるので， :c:func:`Py_DECREF` に使うときの警告を気 にしなくてすみます． ガベージコレクション中に追跡される可能性のある変数の参照デクリメントを行 うには，このマクロを使うのがよいでしょう． .. versionadded:: 2.4 以下の関数: ``Py_IncRef(PyObject *o)``, ``Py_DecRef(PyObject *o)``, -は，実行時の動的な Python 埋め込みで使われる関数です．これらの関数はそれぞ れ :cfunc:`Py_XINCREF` および -:cfunc:`Py_XDECREF` をエクスポートしただけです． - -以下の関数やマクロ: :cfunc:`_Py_Dealloc`, :cfunc:`_Py_ForgetReference`, -:cfunc:`_Py_NewReference` は，インタプリタのコアの内部においてのみ使用する ためのものです。 -また、グローバル変数 :cdata:`_Py_RefTotal` も同様です。 - +は，実行時の動的な Python 埋め込みで使われる関数です．これらの関数はそれぞ れ :c:func:`Py_XINCREF` および +:c:func:`Py_XDECREF` をエクスポートしただけです． + +以下の関数やマクロ: :c:func:`_Py_Dealloc`, :c:func:`_Py_ForgetReference`, +:c:func:`_Py_NewReference` は，インタプリタのコアの内部においてのみ使用する ためのものです。 +また、グローバル変数 :c:data:`_Py_RefTotal` も同様です。 + ======================================= --- /c-api/reflection.rst Thu Dec 2 10:10:59 2010 +++ /c-api/reflection.rst Wed Mar 30 18:55:11 2011 @@ -46,5 +46,5 @@ *func* の型に依存する、解説文字列(description string)を返します。 戻り値は、関数とメソッドに対しては "()", " constructor", " instance", " object" です。 - :cfunc:`PyEval_GetFuncName` と連結された結果、 *func* の解説になります。 - + :c:func:`PyEval_GetFuncName` と連結された結果、 *func* の解説になりま す。 + ======================================= --- /c-api/sequence.rst Mon Nov 29 07:47:56 2010 +++ /c-api/sequence.rst Wed Mar 30 18:55:11 2011 @@ -20,12 +20,12 @@ シーケンス型プロトコルをサポートしないオブジェクトに対しては、 Python の 式 ``len(o)`` と同じになります。 .. versionchanged:: 2.5 - これらの関数は以前は :ctype:`int` を返していました。 + これらの関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: Py_ssize_t PySequence_Length(PyObject *o) - :cfunc:`PySequence_Size` の別名です。 + :c:func:`PySequence_Size` の別名です。 .. cfunction:: PyObject* PySequence_Concat(PyObject *o1, PyObject *o2) @@ -52,7 +52,7 @@ 演算をサポートする場合、in-place 演算を行います。 Python の式 ``o *= count`` と同じです。 .. versionchanged:: 2.5 - この関数は以前は *count* の型に :ctype:`int` を利用していました。 + この関数は以前は *count* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -62,7 +62,7 @@ Python の式 ``o[i]`` と同じです。 .. versionchanged:: 2.5 - この関数は以前は *i* の型に :ctype:`int` を利用していました。 + この関数は以前は *i* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -72,7 +72,7 @@ と同じです。 .. versionchanged:: 2.5 - この関数は以前は *i1*, *i2* の型に :ctype:`int` を利用していました。 + この関数は以前は *i1*, *i2* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PySequence_SetItem(PyObject *o, int Py_ssize_t, PyObject *v) @@ -81,7 +81,7 @@ この関数は *v* への参照を盗み取り *ません* 。 .. versionchanged:: 2.5 - この関数は以前は *i* の型に :ctype:`int` を利用していました。 + この関数は以前は *i* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PySequence_DelItem(PyObject *o, Py_ssize_t i) @@ -89,7 +89,7 @@ *o* の *i* 番目の要素を削除します。失敗すると ``-1`` を返します。 Python の文 ``del o[i]`` と同じです。 .. versionchanged:: 2.5 - この関数は以前は *i* の型に :ctype:`int` を利用していました。 + この関数は以前は *i* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2, PyObject *v) @@ -97,7 +97,7 @@ *o* の *i1* から *i2* までの間のスライスに *v* を代入します。 Python の 文 ``o[i1:i2] = v`` と同じです。 .. versionchanged:: 2.5 - この関数は以前は *i1*, *i2* の型に :ctype:`int` を利用していました。 + この関数は以前は *i1*, *i2* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PySequence_DelSlice(PyObject *o, int Py_ssize_t, int Py_ssize_t) @@ -106,7 +106,7 @@ ``del o[i1:i2]`` と同じです。 .. versionchanged:: 2.5 - この関数は以前は *i1*, *i2* の型に :ctype:`int` を利用していました。 + この関数は以前は *i1*, *i2* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PySequence_Count(PyObject *o, PyObject *value) @@ -115,7 +115,7 @@ ``-1`` を返します。 Python の式 ``o.count(value)`` と同じです。 .. versionchanged:: 2.5 - この関数は以前は :ctype:`int` を返していました。 + この関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PySequence_Contains(PyObject *o, PyObject *value) @@ -131,7 +131,7 @@ ``o.index(value)`` と同じです。 .. versionchanged:: 2.5 - この関数は以前は :ctype:`int` を返していました。 + この関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PySequence_List(PyObject *o) @@ -150,23 +150,23 @@ .. cfunction:: PyObject* PySequence_Fast(PyObject *o, const char *m) シーケンス *o* がすでにタプルやリストであれば *o* を返し、そうでなけれ ば *o* をタプルで返します。返されるタプルのメンバにアクセスするには - :cfunc:`PySequence_Fast_GET_ITEM` を使ってください。失敗すると *NULL* を 返します。 + :c:func:`PySequence_Fast_GET_ITEM` を使ってください。失敗すると *NULL* を返します。 オブジェクトがシーケンスでなければ、 *m* がメッセージテキストになってい る :exc:`TypeError` を送出します。 .. cfunction:: PyObject* PySequence_Fast_GET_ITEM(PyObject *o, Py_ssize_t i) - *o* が *NULL* でなく、 :cfunc:`PySequence_Fast` が返したオブジェクトであ り、かつ *i* がインデクスの範囲内にあると + *o* が *NULL* でなく、 :c:func:`PySequence_Fast` が返したオブジェクトで あり、かつ *i* がインデクスの範囲内にあると 仮定して、 *o* の *i* 番目の要素を返します。 .. versionchanged:: 2.5 - この関数は以前は *i* の型に :ctype:`int` を利用していました。 + この関数は以前は *i* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject** PySequence_Fast_ITEMS(PyObject *o) PyObject ポインタの背後にあるアレイを返します． - この関数では， *o* は :cfunc:`PySequence_Fast` の返したオブジェクトであ り， + この関数では， *o* は :c:func:`PySequence_Fast` の返したオブジェクトであ り， *NULL* でないものと仮定しています． リストのサイズが変更されるとき、メモリ再確保が要素の配列を再配置するかも しれない @@ -179,17 +179,17 @@ .. cfunction:: PyObject* PySequence_ITEM(PyObject *o, Py_ssize_t i) 成功すると the *i* th element of *o* を返し、失敗すると *NULL* を返しま す。 - :cfunc:`PySequence_GetItem` ですが、 :cfunc:`PySequence_Check(o)` が真に なるかチェックせず、 + :c:func:`PySequence_GetItem` ですが、 :c:func:`PySequence_Check(o)` が真 になるかチェックせず、 負のインデクスに対する調整を行いません。 .. versionadded:: 2.3 .. versionchanged:: 2.5 - この関数は以前は *i* の型に :ctype:`int` を利用していました。 + この関数は以前は *i* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PySequence_Fast_GET_SIZE(PyObject *o) - *o* が *NULL* でなく、 :cfunc:`PySequence_Fast` が返したオブジェクトであ ると仮定して、 *o* の長さを返します。 *o* - のサイズは :cfunc:`PySequence_Size` を呼び出しても得られます が、 :cfunc:`PySequence_Fast_GET_SIZE` + *o* が *NULL* でなく、 :c:func:`PySequence_Fast` が返したオブジェクトで あると仮定して、 *o* の長さを返します。 *o* + のサイズは :c:func:`PySequence_Size` を呼び出しても得られます が、 :c:func:`PySequence_Fast_GET_SIZE` の方が *o* をリストかタプルであると仮定して処理するため、より高速です。 ======================================= --- /c-api/set.rst Wed Dec 1 02:31:02 2010 +++ /c-api/set.rst Wed Mar 30 18:55:11 2011 @@ -15,19 +15,19 @@ .. versionadded:: 2.5 このセクションでは :class:`set` と :class:`frozenset` の公開APIについて詳し く述べます。 -以降で説明していない機能は、抽象オブジェクトプロトコル ( :cfunc:`PyObject_CallMethod`, -:cfunc:`PyObject_RichCompareBool`, :cfunc:`PyObject_Hash`, -:cfunc:`PyObject_Repr`, :cfunc:`PyObject_IsTrue`, :cfunc:`PyObject_Print`, -:cfunc:`PyObject_GetIter` を含む) か抽象数値プロトコル ( :cfunc:`PyNumber_Add`, -:cfunc:`PyNumber_Subtract`, :cfunc:`PyNumber_Or`, :cfunc:`PyNumber_Xor`, -:cfunc:`PyNumber_InPlaceAdd`, :cfunc:`PyNumber_InPlaceSubtract`, -:cfunc:`PyNumber_InPlaceOr`, :cfunc:`PyNumber_InPlaceXor` を含む) を使って 利用できます。 +以降で説明していない機能は、抽象オブジェクトプロトコル ( :c:func:`PyObject_CallMethod`, +:c:func:`PyObject_RichCompareBool`, :c:func:`PyObject_Hash`, +:c:func:`PyObject_Repr`, :c:func:`PyObject_IsTrue`, :c:func:`PyObject_Print`, +:c:func:`PyObject_GetIter` を含む) か抽象数値プロトコル ( :c:func:`PyNumber_Add`, +:c:func:`PyNumber_Subtract`, :c:func:`PyNumber_Or`, :c:func:`PyNumber_Xor`, +:c:func:`PyNumber_InPlaceAdd`, :c:func:`PyNumber_InPlaceSubtract`, +:c:func:`PyNumber_InPlaceOr`, :c:func:`PyNumber_InPlaceXor` を含む) を使っ て利用できます。 .. ctype:: PySetObject - この :ctype:`PyObject` を継承した型は、 :class:`set` と :class:`frozenset` 両方の - 内部データを保存するのに用いられます。 :ctype:`PyDictObject` + この :c:type:`PyObject` を継承した型は、 :class:`set` と :class:`frozenset` 両方の + 内部データを保存するのに用いられます。 :c:type:`PyDictObject` と同じように、小さい集合(set)に対しては(タプルのように)固定サイズであ り、 そうでない集合に対しては(リストと同じように)可変長のメモリブロックを用い ます。この構造体のどのフィールドも、非公開で変更される可能性があると考えて下 さい。 すべてのアクセスは、構造体の中の値を直接操作するのではなく、ドキュメント された APIを用いて行うべきです。 @@ -35,12 +35,12 @@ .. cvar:: PyTypeObject PySet_Type - この :ctype:`PyTypeObject` のインスタンスは、Pythonの :class:`set` 型を 表します。 + この :c:type:`PyTypeObject` のインスタンスは、Pythonの :class:`set` 型を 表します。 .. cvar:: PyTypeObject PyFrozenSet_Type - この :ctype:`PyTypeObject` のインスタンスは、 Pythonの :class:`frozenset` 型を表します。 + この :c:type:`PyTypeObject` のインスタンスは、 Pythonの :class:`frozenset` 型を表します。 以降の型チェックマクロはすべてのPythonオブジェクトに対するポインタに対して 動作します。 同様に、コンストラクタはすべてのイテレート可能なPythonオブジェクトに対して 動作します。 @@ -105,12 +105,12 @@ 無い場合は、 :exc:`PyExc_SystemError` を送出します。 .. versionchanged:: 2.5 - これらの関数は以前は :ctype:`int` を返していました。 + これらの関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: Py_ssize_t PySet_GET_SIZE(PyObject *anyset) - エラーチェックを行わない、 :cfunc:`PySet_Size` のマクロ形式。 + エラーチェックを行わない、 :c:func:`PySet_Size` のマクロ形式。 .. cfunction:: int PySet_Contains(PyObject *anyset, PyObject *key) @@ -131,7 +131,7 @@ .. versionchanged:: 2.6 :class:`frozenset` やそのサブタイプのインスタンスに対して利用できる ようになりました。 - :cfunc:`PyTuple_SetItem` のように、新しい frozenset を他のコードに渡 す + :c:func:`PyTuple_SetItem` のように、新しい frozenset を他のコードに渡 す まえに内容を追加するためのに使うことができます。 以降の関数は、 :class:`set` とそのサブタイプに対して利用可能です。 ======================================= --- /c-api/slice.rst Wed Dec 1 02:15:19 2010 +++ /c-api/slice.rst Wed Mar 30 18:55:11 2011 @@ -34,16 +34,16 @@ :const:`None` ではなく、かつ整数に変換できなかった場合を除きます。この場 合、 ``-1`` を返して例外をセットします)。 おそらくこの関数を使う気にはならないでしょう。バージョン 2.3 以前の Python でスライスオブジェクトを使いたいのなら、 - :cfunc:`PySlice_GetIndicesEx` のソースを適切に名前変更して自分の拡張モジ ュールのソースコード内に組み込むとよいでしょう。 + :c:func:`PySlice_GetIndicesEx` のソースを適切に名前変更して自分の拡張モ ジュールのソースコード内に組み込むとよいでしょう。 .. versionchanged:: 2.5 - この関数は以前は *length* の型に :ctype:`int` を、 *start*, *stop*, *step* - の型に :ctype:`int *` を利用していました。 + この関数は以前は *length* の型に :c:type:`int` を、 *start*, *stop*, *step* + の型に :c:type:`int *` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PySlice_GetIndicesEx(PySliceObject *slice, Py_ssize_t length, Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, Py_ssize_t *slicelength) - :cfunc:`PySlice_GetIndices` の置き換えとして使える関数です。 + :c:func:`PySlice_GetIndices` の置き換えとして使える関数です。 スライスオブジェクト *slice* における *start*, *stop*, および *step* の インデクス値を取得します。このときシーケンスの 長さを *length* と仮定します。スライスの長さを *slicelength* に記憶しま す。境界をはみだしたインデクスは、通常のスライスを扱うのと @@ -54,6 +54,6 @@ .. versionadded:: 2.3 .. versionchanged:: 2.5 - この関数は以前は *length* の型に :ctype:`int` を、 *start*, *stop*, *step*, - *slicelength* の型に :ctype:`int *` を利用していました。 + この関数は以前は *length* の型に :c:type:`int` を、 *start*, *stop*, *step*, + *slicelength* の型に :c:type:`int *` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 ======================================= --- /c-api/string.rst Mon Nov 29 09:07:22 2010 +++ /c-api/string.rst Wed Mar 30 18:55:11 2011 @@ -18,14 +18,14 @@ .. ctype:: PyStringObject - この :ctype:`PyObject` のサブタイプは Python の文字列オブジェクトを表現 します。 + この :c:type:`PyObject` のサブタイプは Python の文字列オブジェクトを表現 します。 .. cvar:: PyTypeObject PyString_Type .. index:: single: StringType (in module types) - この :ctype:`PyTypeObject` のインスタンスは Python の文字列型を表現しま す; このオブジェクトは Python レイヤにおける + この :c:type:`PyTypeObject` のインスタンスは Python の文字列型を表現しま す; このオブジェクトは Python レイヤにおける ``str`` や ``types.TypeType`` と同じです。 . @@ -56,12 +56,12 @@ の場合、文字列の中身は未初期化の状態になります。 .. versionchanged:: 2.5 - この関数は以前は *len* の型に :ctype:`int` を利用していました。 + この関数は以前は *len* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyString_FromFormat(const char *format, ...) - C 関数 :cfunc:`printf` 形式の *format* 文字列と可変個の引数をとり、書式 化済みの文字列長を計算した上で、書式化を行った結果を + C 関数 :c:func:`printf` 形式の *format* 文字列と可変個の引数をとり、書式 化済みの文字列長を計算した上で、書式化を行った結果を 値とする Python 文字列にして返します。可変個の引数部は C のデータ型でな くてはならず、かつ *format* 文字列内の書式指定文字 (format character) に一致する型でなくてはなりません。利用できる書式化文字は以下 の通りです: @@ -109,7 +109,7 @@ .. cfunction:: PyObject* PyString_FromFormatV(const char *format, va_list vargs) - :cfunc:`PyString_FromFormat` と同じです。ただし、こちらの関数は二つしか 引数をとりません。 + :c:func:`PyString_FromFormat` と同じです。ただし、こちらの関数は二つしか 引数をとりません。 .. cfunction:: Py_ssize_t PyString_Size(PyObject *string) @@ -117,15 +117,15 @@ 文字列オブジェクト *string* 内の文字列値の長さを返します。 .. versionchanged:: 2.5 - この関数は以前は :ctype:`int` を返していました。 + この関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: Py_ssize_t PyString_GET_SIZE(PyObject *string) - :cfunc:`PyString_Size` をマクロで実装したもので、エラーチェックを行いま せん。 + :c:func:`PyString_Size` をマクロで実装したもので、エラーチェックを行いま せん。 .. versionchanged:: 2.5 - この関数は以前は :ctype:`int` を返していました。 + この関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -135,13 +135,13 @@ バッファのコピーを指すわけではありません。 ``PyString_FromStringAndSize(NULL, size)`` を使って 生成した文字列でない限り、バッファ内のデータはいかなる変更もしてはなりま せん。この文字列をデアロケートしてはなりません。 *string* が Unicode オブジェクトの場合、この関数は *string* のデフォルトエンコーディング版を 計算し、デフォルトエンコーディング版に対して操作を行います。 - *string* が文字列オブジェクトですらない場 合、 :cfunc:`PyString_AsString` は *NULL* を返して + *string* が文字列オブジェクトですらない場 合、 :c:func:`PyString_AsString` は *NULL* を返して :exc:`TypeError` を送出します。 .. cfunction:: char* PyString_AS_STRING(PyObject *string) - :cfunc:`PyString_AsString` をマクロで実装したもので、エラーチェックを行 いません。文字列オブジェクトだけをサポートします; + :c:func:`PyString_AsString` をマクロで実装したもので、エラーチェックを行 いません。文字列オブジェクトだけをサポートします; Unicode オブジェクトを渡してはなりません。 @@ -160,10 +160,10 @@ *string* が Unicode オブジェクトの場合、この関数は *string* のデフォルト エンコーディング版を計算し、 デフォルトエンコーディング版に対して操作を行います。 *string* が文字列オ ブジェクトですらない場合、 - :cfunc:`PyString_AsStringAndSize` は ``-1`` を返して :exc:`TypeError` を 送出します。 + :c:func:`PyString_AsStringAndSize` は ``-1`` を返して :exc:`TypeError` を送出します。 .. versionchanged:: 2.5 - この関数は以前は *length* の型に :ctype:`int *` を利用していました。 + この関数は以前は *length* の型に :c:type:`int *` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: void PyString_Concat(PyObject **string, PyObject *newpart) @@ -190,7 +190,7 @@ を返します。 .. versionchanged:: 2.5 - この関数は以前は *newsize* の型に :ctype:`int` を利用していました。 + この関数は以前は *newsize* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyString_Format(PyObject *format, PyObject *args) @@ -212,7 +212,7 @@ .. cfunction:: PyObject* PyString_InternFromString(const char *v) - :cfunc:`PyString_FromString` と :cfunc:`PyString_InternInPlace` を組み 合わせたもので、 + :c:func:`PyString_FromString` と :c:func:`PyString_InternInPlace` を組 み合わせたもので、 隔離済みの新たな文字列オブジェクトを返すか、同じ値を持つすでに隔離済みの 文字列オブジェクトに対する新たな ("所有権を得た") 参照を返します。 .. note:: @@ -229,7 +229,7 @@ この関数は 3.x では利用できず、 PyBytes エイリアスもありません。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -244,7 +244,7 @@ .. cfunction:: PyObject* PyString_Encode(const char *s, Py_ssize_t size, const char *encoding, const char *errors) - *size* で指定されたサイズの :ctype:`char` バッファを *encoding* の名前で 登録されている codec に渡してエンコードし、 + *size* で指定されたサイズの :c:type:`char` バッファを *encoding* の名前 で登録されている codec に渡してエンコードし、 Python オブジェクトを返します。 *encoding* および *errors* は文字列型 の :meth:`encode` メソッドに与える同名のパラメタと同じ意味を持ちます。使用する codec の検 索は、 Python の codec レジストリを使って行います。codec が例外を送出した場合には *NULL* を返します。 @@ -253,7 +253,7 @@ この関数は 3.x では利用できず、 PyBytes エイリアスもありません。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyString_AsEncodedObject(PyObject *str, const char *encoding, const char *errors) ======================================= --- /c-api/structures.rst Wed Dec 1 09:22:31 2010 +++ /c-api/structures.rst Wed Mar 30 18:55:11 2011 @@ -8,8 +8,8 @@ Python では、オブジェクト型を定義する上で数多くの構造体が使われます。この節 では三つの構造体とその利用方法について説明します。 全ての Python オブジェクトは、オブジェクトのメモリ内表現の先頭部分にある少 数のフィールドを完全に共有しています。このフィールドは -:ctype:`PyObject` および :ctype:`PyVarObject` 型で表現されま す。 :ctype:`PyObject` 型や -:ctype:`PyVarObject` 型もまた、他の全ての Python オブジェクトを定義する上 で直接的・間接的に使われているマクロを +:c:type:`PyObject` および :c:type:`PyVarObject` 型で表現されま す。 :c:type:`PyObject` 型や +:c:type:`PyVarObject` 型もまた、他の全ての Python オブジェクトを定義する上 で直接的・間接的に使われているマクロを 使って定義されています。 @@ -26,24 +26,24 @@ .. ctype:: PyVarObject - :ctype:`PyObject` を拡張して、 :attr:`ob_size` フィールドを追加したもの です。この構造体は、 *長さ (length)* + :c:type:`PyObject` を拡張して、 :attr:`ob_size` フィールドを追加したもの です。この構造体は、 *長さ (length)* の概念を持つオブジェクトだけに対して使います。この型が Python/C API で使 われることはほとんどありません。 ``PyObject_VAR_HEAD`` マクロ展開で定義されているフィールドに対応します。 -:ctype:`PyObject` および :ctype:`PyVarObject` の定義には以下のマクロが使わ れています: +:c:type:`PyObject` および :c:type:`PyVarObject` の定義には以下のマクロが使 われています: .. cmacro:: PyObject_HEAD - :ctype:`PyObject` 型のフィールド宣言に展開されるマクロです; 可変でない 長さを持つオブジェクトを表現する新たな型を宣言する - 場合に使います。展開によってどのフィールドが宣言されるか は、 :cmacro:`Py_TRACE_REFS` の定義に依存します。 - デフォルトでは、 :cmacro:`Py_TRACE_REFS` は定義されておら ず、 :cmacro:`PyObject_HEAD` + :c:type:`PyObject` 型のフィールド宣言に展開されるマクロです; 可変でない 長さを持つオブジェクトを表現する新たな型を宣言する + 場合に使います。展開によってどのフィールドが宣言されるか は、 :c:macro:`Py_TRACE_REFS` の定義に依存します。 + デフォルトでは、 :c:macro:`Py_TRACE_REFS` は定義されておら ず、 :c:macro:`PyObject_HEAD` は以下のコードに展開されます:: Py_ssize_t ob_refcnt; PyTypeObject *ob_type; - :cmacro:`Py_TRACE_REFS` が定義されている場合、以下のように展開されます:: + :c:macro:`Py_TRACE_REFS` が定義されている場合、以下のように展開されま す:: PyObject *_ob_next, *_ob_prev; Py_ssize_t ob_refcnt; @@ -52,19 +52,19 @@ .. cmacro:: PyObject_VAR_HEAD - マクロです。 :ctype:`PyVarObject` 型のフィールド宣言に展開されるマクロで す; + マクロです。 :c:type:`PyVarObject` 型のフィールド宣言に展開されるマクロ です; インスタンスによって可変の長さを持つオブジェクトを表現する新たな型を宣言 する場合に使います。マクロは常に以下のように展開されます:: PyObject_HEAD Py_ssize_t ob_size; - マクロ展開結果の一部に :cmacro:`PyObject_HEAD` が含まれてお り、 :cmacro:`PyObject_HEAD` - の展開結果は :cmacro:`Py_TRACE_REFS` の定義に依存します。 + マクロ展開結果の一部に :c:macro:`PyObject_HEAD` が含まれてお り、 :c:macro:`PyObject_HEAD` + の展開結果は :c:macro:`Py_TRACE_REFS` の定義に依存します。 .. cmacro:: PyObject_HEAD_INIT(type) - 新しい :ctype:`PyObject` 型のための初期値に展開するマクロです。 + 新しい :c:type:`PyObject` 型のための初期値に展開するマクロです。 このマクロは次のように展開されます。 :: _PyObject_EXTRA_INIT @@ -73,7 +73,7 @@ .. cmacro:: PyVarObject_HEAD_INIT(type, size) - 新しい、 :attr:`ob_size` フィールドを含む :ctype:`PyVarObject` + 新しい、 :attr:`ob_size` フィールドを含む :c:type:`PyVarObject` 型のための初期値に展開するマクロです。 このマクロは次のように展開されます。 :: @@ -84,7 +84,7 @@ .. ctype:: PyCFunction ほとんどの Python の呼び出し可能オブジェクトを C で実装する際に用いられ ている関数の型です。この型の関数は二つの - :ctype:`PyObject\*` 型パラメタをとり、 :ctype:`PyObject\*` 型の値を返し ます。戻り値を *NULL* にする場合、 + :c:type:`PyObject\*` 型パラメタをとり、 :c:type:`PyObject\*` 型の値を返 します。戻り値を *NULL* にする場合、 例外をセットしておかなければなりません。 *NULL* でない値を返す場合、戻り 値は Python に関数の戻り値として公開される値として解釈されます。 この型の関数は新たな参照を返さなければなりません。 @@ -105,9 +105,9 @@ | :attr:`ml_doc` | char \* | docstring の内容を指すポイン タ | +------------------+-------------+----------------------------------------------+ -:attr:`ml_meth` は C の関数ポインタです。関数は別の型で定義されていてもかま いませんが、常に :ctype:`PyObject\*` -を返します。関数が :ctype:`PyFunction` でない場合、メソッドテーブル内でキャ ストを行うようコンパイラが要求することになるでしょう。 -:ctype:`PyCFunction` では最初のパラメタが :ctype:`PyObject\*` 型であると定 義していますが、固有の C 型を +:attr:`ml_meth` は C の関数ポインタです。関数は別の型で定義されていてもかま いませんが、常に :c:type:`PyObject\*` +を返します。関数が :c:type:`PyFunction` でない場合、メソッドテーブル内でキ ャストを行うようコンパイラが要求することになるでしょう。 +:c:type:`PyCFunction` では最初のパラメタが :c:type:`PyObject\*` 型であると 定義していますが、固有の C 型を *self* オブジェクトに使う実装はよく行われています。 :attr:`ml_flags` フィールドはビットフィールドで、以下のフラグが入ります。 個々のフラグは呼び出し規約 (calling convention) @@ -118,38 +118,38 @@ .. data:: METH_VARARGS - :ctype:`PyCFunction` 型のメソッドで典型的に使われる呼び出し規約です。関 数は :ctype:`PyObject\*` - 型の引数値を二つ要求します。最初の引数はメソッドの *self* オブジェクトで す; モジュール関数の場合、 :cfunc:`Py_InitModule4` - に与えることになる値が入ります (*NULL* にすると :cfunc:`Py_InitModule` が使われます)。第二のパラメタ (よく *args* - と呼ばれます) は、全ての引数を表現するタプルオブジェクトです。パラメタは 通常、 :cfunc:`PyArg_ParseTuple` や - :cfunc:`PyArg_UnpackTuple` で処理されます。 + :c:type:`PyCFunction` 型のメソッドで典型的に使われる呼び出し規約です。関 数は :c:type:`PyObject\*` + 型の引数値を二つ要求します。最初の引数はメソッドの *self* オブジェクトで す; モジュール関数の場合、 :c:func:`Py_InitModule4` + に与えることになる値が入ります (*NULL* にすると :c:func:`Py_InitModule` が使われます)。第二のパラメタ (よく *args* + と呼ばれます) は、全ての引数を表現するタプルオブジェクトです。パラメタは 通常、 :c:func:`PyArg_ParseTuple` や + :c:func:`PyArg_UnpackTuple` で処理されます。 .. data:: METH_KEYWORDS - このフラグを持つメソッドは :ctype:`PyCFunctionWithKeywords` - 型でなければなりません。 :ctype:`PyCFunctionWithKeywords` は三つのパラメ タ:*self* 、 *args* 、 + このフラグを持つメソッドは :c:type:`PyCFunctionWithKeywords` + 型でなければなりません。 :c:type:`PyCFunctionWithKeywords` は三つのパラ メタ:*self* 、 *args* 、 およびキーワード引数全てからなる辞書、を要求します。このフラグは通 常 :const:`METH_VARARGS` と組み合わされ、パラメタは - :cfunc:`PyArg_ParseTupleAndKeywords` で処理されます。 + :c:func:`PyArg_ParseTupleAndKeywords` で処理されます。 .. data:: METH_NOARGS 引数のないメソッドは、 :const:`METH_NOARGS` フラグをつけた場合、必要な引 数が指定されているかをチェックしなくなります。こうしたメソッドは - :ctype:`PyCFunction` 型でなくてはなりません。オブジェクトのメソッドに使 った場合、第一のパラメタは ``self`` + :c:type:`PyCFunction` 型でなくてはなりません。オブジェクトのメソッドに使 った場合、第一のパラメタは ``self`` になり、オブジェクトインスタンスへの参照を保持することになります。いずれ にせよ、第二のパラメタは *NULL* になります。 .. data:: METH_O - 単一のオブジェクト引数だけをとるメソッドは、 :cfunc:`PyArg_ParseTuple` を引数 ``"O"`` にして呼び出す代わりに、 - :const:`METH_O` フラグつきで指定できます。メソッド は :ctype:`PyCFunction` 型で、 *self* - パラメタと単一の引数を表現する :ctype:`PyObject\*` パラメタを伴います。 + 単一のオブジェクト引数だけをとるメソッドは、 :c:func:`PyArg_ParseTuple` を引数 ``"O"`` にして呼び出す代わりに、 + :const:`METH_O` フラグつきで指定できます。メソッド は :c:type:`PyCFunction` 型で、 *self* + パラメタと単一の引数を表現する :c:type:`PyObject\*` パラメタを伴います。 .. data:: METH_OLDARGS - この呼び出し規約は撤廃されました。メソッドは :ctype:`PyCFunction` 型でな ければなりません。第二引数は、引数がない場合には + この呼び出し規約は撤廃されました。メソッドは :c:type:`PyCFunction` 型で なければなりません。第二引数は、引数がない場合には *NULL* 、単一の引数の場合にはその引数オブジェクト、複数個の引数の場合に は引数オブジェクトからなるタプルです。この呼び出し規約を使うと、複数個の 引数の場合と、単一のタプルが唯一引数の場合を区別できなくなってしまいま す。 @@ -243,21 +243,21 @@ T_PYSSIZET Py_ssize_t =============== ================== - :cmacro:`T_OBJECT` と :cmacro:`T_OBJECT_EX` は、 - :cmacro:`T_OBJECT` がメンバが *NULL* だったときに ``None`` を返すのに対 し、 - :cmacro:`T_OBJECT_EX` は :exc:`AttributeError` を発生させる点が異なりま す。 - :cmacro:`T_OBJECT_EX` は属性に対する :keyword:`del` 文をより正しくあつか うので、 - できれば :cmacro:`T_OBJECT` よりも :cmacro:`T_OBJECT_EX` を使ってくださ い。 + :c:macro:`T_OBJECT` と :c:macro:`T_OBJECT_EX` は、 + :c:macro:`T_OBJECT` がメンバが *NULL* だったときに ``None`` を返すのに対 し、 + :c:macro:`T_OBJECT_EX` は :exc:`AttributeError` を発生させる点が異なりま す。 + :c:macro:`T_OBJECT_EX` は属性に対する :keyword:`del` 文をより正しくあつ かうので、 + できれば :c:macro:`T_OBJECT` よりも :c:macro:`T_OBJECT_EX` を使ってくだ さい。 :attr:`flags` には読み書きアクセス可能なら 0 で、読み込み専用なら - :cmacro:`READONLY` を設定します。 - :attr:`type` に :cmacro:`T_STRING` を使うと、強制的に :cmacro:`READONLY` + :c:macro:`READONLY` を設定します。 + :attr:`type` に :c:macro:`T_STRING` を使うと、強制的 に :c:macro:`READONLY` 扱いになります。 - :cmacro:`T_OBJECT` and :cmacro:`T_OBJECT_EX` メンバだけが del 可能です。 + :c:macro:`T_OBJECT` and :c:macro:`T_OBJECT_EX` メンバだけが del 可能で す。 (*NULL* が代入されます). .. cfunction:: PyObject* Py_FindMethod(PyMethodDef table[], PyObject *ob, char *name) - C で実装された拡張型の束縛メソッドオブジェクトを返しま す。 :cfunc:`PyObject_GenericGetAttr` 関数を使わない + C で実装された拡張型の束縛メソッドオブジェクトを返しま す。 :c:func:`PyObject_GenericGetAttr` 関数を使わない :attr:`tp_getattro` や :attr:`tp_getattr` ハンドラを実装する際に便利で す。 ======================================= --- /c-api/sys.rst Sun Nov 28 10:04:33 2010 +++ /c-api/sys.rst Wed Mar 30 18:55:11 2011 @@ -9,14 +9,14 @@ .. cfunction:: int Py_FdIsInteractive(FILE *fp, const char *filename) *filename* という名前の標準 I/O ファイル *fp* が対話的 (interactive) で あると考えられる場合に真 (非ゼロ) を返します。 - これは ``isatty(fileno(fp))`` が真になるファイルの場合です。グローバルな フラグ :cdata:`Py_InteractiveFlag` + これは ``isatty(fileno(fp))`` が真になるファイルの場合です。グローバルな フラグ :c:data:`Py_InteractiveFlag` が真の場合には、 *filename* ポインタが *NULL* か、名前が ``'<stdin>'`` または ``'???'`` のいずれかに等しい場合にも真を返します。 .. cfunction:: long PyOS_GetLastModificationTime(char *filename) - ファイル *filename* の最終更新時刻を返します。結果は標準 C ライブラリ関 数 :cfunc:`time` が返すタイムスタンプと + ファイル *filename* の最終更新時刻を返します。結果は標準 C ライブラリ関 数 :c:func:`time` が返すタイムスタンプと 同じ様式で符号化されています。 @@ -35,16 +35,16 @@ .. cfunction:: PyOS_sighandler_t PyOS_getsig(int i) - シグナル *i* に対する現在のシグナルハンドラを返します。この関数 は :cfunc:`sigaction` または :cfunc:`signal` - のいずれかに対する薄いラッパです。 :cfunc:`sigaction` や :cfunc:`signal` を直接呼び出してはなりません! - :ctype:`PyOS_sighandler_t` は :ctype:`void (\*)(int)` の typedef による 別名です。 + シグナル *i* に対する現在のシグナルハンドラを返します。この関数 は :c:func:`sigaction` または :c:func:`signal` + のいずれかに対する薄いラッパです。 :c:func:`sigaction` や :c:func:`signal` を直接呼び出してはなりません! + :c:type:`PyOS_sighandler_t` は :c:type:`void (\*)(int)` の typedef によ る別名です。 .. cfunction:: PyOS_sighandler_t PyOS_setsig(int i, PyOS_sighandler_t h) シグナル *i* に対する現在のシグナルハンドラを *h* に設定します; 以前のシ グナルハンドラを返します。この関数は - :cfunc:`sigaction` または :cfunc:`signal` のいずれかに対する薄いラッパで す。 :cfunc:`sigaction` や - :cfunc:`signal` を直接呼び出してはなりませ ん! :ctype:`PyOS_sighandler_t` は :ctype:`void + :c:func:`sigaction` または :c:func:`signal` のいずれかに対する薄いラッパ です。 :c:func:`sigaction` や + :c:func:`signal` を直接呼び出してはなりませ ん! :c:type:`PyOS_sighandler_t` は :c:type:`void (\*)(int)` の typedef による別名です。 @@ -64,8 +64,8 @@ .. cfunction:: FILE *PySys_GetFile(char *name, FILE *def) - :mod:`sys` モジュールの *name* に関連付けられた :ctype:`FILE*` を返しま す。 - *name* がなかった場合や :ctype:`FILE*` に関連付けられていなかった場合は *def* を返します。 + :mod:`sys` モジュールの *name* に関連付けられた :c:type:`FILE*` を返しま す。 + *name* がなかった場合や :c:type:`FILE*` に関連付けられていなかった場合 は *def* を返します。 .. cfunction:: int PySys_SetObject(char *name, PyObject *v) @@ -120,7 +120,7 @@ 致命的エラーメッセージ (fatal error message) を出力してプロセスを強制終 了 (kill) します。後始末処理は行われません。この関数は、Python インタプリタを使い 続けるのが危険であるような状況が検出されたとき; 例えば、オブジェクト管理が崩壊していると思われるときにのみ、呼び出される ようにしなければなりません。Unixでは、標準 C ライブラリ関数 - :cfunc:`abort` を呼び出して :file:`core` を生成しようと試みます。 + :c:func:`abort` を呼び出して :file:`core` を生成しようと試みます。 .. cfunction:: void Py_Exit(int status) @@ -129,7 +129,7 @@ single: Py_Finalize() single: exit() - 現在のプロセスを終了 (exit) します。この関数は :cfunc:`Py_Finalize` を呼 び出し、次いで標準 C ライブラリ関数 + 現在のプロセスを終了 (exit) します。この関数は :c:func:`Py_Finalize` を 呼び出し、次いで標準 C ライブラリ関数 ``exit(status)`` を呼び出します。 @@ -139,7 +139,7 @@ single: Py_Finalize() single: cleanup functions - :cfunc:`Py_Finalize` から呼び出される後始末処理を行う関数 (cleanup function) を登録します。 - 後始末関数は引数無しで呼び出され、値を返しません。最大で 32 の後始末処理 関数を登録できます。登録に成功すると、 :cfunc:`Py_AtExit` は + :c:func:`Py_Finalize` から呼び出される後始末処理を行う関数 (cleanup function) を登録します。 + 後始末関数は引数無しで呼び出され、値を返しません。最大で 32 の後始末処理 関数を登録できます。登録に成功すると、 :c:func:`Py_AtExit` は ``0`` を返します; 失敗すると ``-1`` を返します。最後に登録した後始末処 理関数から先に呼び出されます。各関数は高々一度しか呼び出されません。 Python の内部的な終了処理は後始末処理関数より以前に完了しているので、 *func* からはいかなる Python API も呼び出してはなりません。 ======================================= --- /c-api/tuple.rst Tue Nov 30 19:26:17 2010 +++ /c-api/tuple.rst Wed Mar 30 18:55:11 2011 @@ -10,14 +10,14 @@ .. ctype:: PyTupleObject - この :ctype:`PyObject` のサブタイプは Python のタプルオブジェクトを表現 します。 + この :c:type:`PyObject` のサブタイプは Python のタプルオブジェクトを表現 します。 .. cvar:: PyTypeObject PyTuple_Type .. index:: single: TupleType (in module types) - この :ctype:`PyTypeObject` のインスタンスは Python のタプル型を表現しま す; Python レイヤにおける ``tuple`` + この :c:type:`PyTypeObject` のインスタンスは Python のタプル型を表現しま す; Python レイヤにおける ``tuple`` や ``types.TupleType`` と同じオブジェクトです。 @@ -41,7 +41,7 @@ サイズが *len* 新たなタプルオブジェクトを返します。失敗すると *NULL* を 返します。 .. versionchanged:: 2.5 - この関数は以前は *len* の型に :ctype:`int` を利用していました。 + この関数は以前は *len* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyTuple_Pack(Py_ssize_t n, ...) @@ -52,7 +52,7 @@ .. versionadded:: 2.4 .. versionchanged:: 2.5 - この関数は以前は *n* の型に :ctype:`int` を利用していました。 + この関数は以前は *n* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: Py_ssize_t PyTuple_Size(PyObject *p) @@ -60,7 +60,7 @@ タプルオブジェクトへのポインタを引数にとり、そのタプルのサイズを返しま す。 .. versionchanged:: 2.5 - これらの関数は以前は :ctype:`int` を返していました。 + これらの関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: Py_ssize_t PyTuple_GET_SIZE(PyObject *p) @@ -69,7 +69,7 @@ エラーチェックを行いません。 .. versionchanged:: 2.5 - これらの関数は以前は :ctype:`int` を返していました。 + これらの関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyTuple_GetItem(PyObject *p, Py_ssize_t pos) @@ -78,15 +78,15 @@ :exc:`IndexError` 例外をセットします。 .. versionchanged:: 2.5 - この関数は以前は *pos* の型に :ctype:`int` を利用していました。 + この関数は以前は *pos* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyTuple_GET_ITEM(PyObject *p, Py_ssize_t pos) - :cfunc:`PyTuple_GetItem` に似ていますが、引数に対するエラーチェックを行 いません。 + :c:func:`PyTuple_GetItem` に似ていますが、引数に対するエラーチェックを行 いません。 .. versionchanged:: 2.5 - この関数は以前は *pos* の型に :ctype:`int` を利用していました。 + この関数は以前は *pos* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyTuple_GetSlice(PyObject *p, Py_ssize_t low, Py_ssize_t high) @@ -94,7 +94,7 @@ *p* の指すタプルオブジェクト内の、位置 *low* から *high* までのスライス を取り出して、タプルオブジェクトとして返します。 .. versionchanged:: 2.5 - この関数は以前は *low*, *high* の型に :ctype:`int` を利用していまし た。 + この関数は以前は *low*, *high* の型に :c:type:`int` を利用していまし た。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PyTuple_SetItem(PyObject *p, Py_ssize_t pos, PyObject *o) @@ -106,19 +106,19 @@ この関数は *o* への参照を "盗み取り" ます。 .. versionchanged:: 2.5 - この関数は以前は *pos* の型に :ctype:`int` を利用していました。 + この関数は以前は *pos* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: void PyTuple_SET_ITEM(PyObject *p, Py_ssize_t pos, PyObject *o) - :cfunc:`PyTuple_SetItem` に似ていますが、エラーチェックを行わず、新たな タプルに値を入れるとき *以外には使ってはなりません* 。 + :c:func:`PyTuple_SetItem` に似ていますが、エラーチェックを行わず、新たな タプルに値を入れるとき *以外には使ってはなりません* 。 .. note:: この関数は *o* への参照を "盗み取り" ます。 .. versionchanged:: 2.5 - この関数は以前は *pos* の型に :ctype:`int` を利用していました。 + この関数は以前は *pos* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int _PyTuple_Resize(PyObject **p, Py_ssize_t newsize) @@ -134,7 +134,7 @@ 使われていなかった三つ目のパラメタ、 *last_is_sticky* を削除しました. .. versionchanged:: 2.5 - この関数は以前は *newsize* の型に :ctype:`int` を利用していました。 + この関数は以前は *newsize* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: int PyTuple_ClearFreeList() ======================================= --- /c-api/type.rst Mon Nov 29 09:07:22 2010 +++ /c-api/type.rst Wed Mar 30 18:55:11 2011 @@ -75,7 +75,7 @@ .. versionadded:: 2.2 .. versionchanged:: 2.5 - この関数は以前は *nitems* の型に :ctype:`int` を利用していました。 + この関数は以前は *nitems* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 ======================================= --- /c-api/typeobj.rst Sun Mar 20 19:57:59 2011 +++ /c-api/typeobj.rst Wed Mar 30 18:55:11 2011 @@ -5,9 +5,9 @@ 型オブジェクト ============== -新スタイルの型を定義する構造体: :ctype:`PyTypeObject` 構造体は、おそらく Python +新スタイルの型を定義する構造体: :c:type:`PyTypeObject` 構造体は、おそらく Python オブジェクトシステムの中で最も重要な構造体の1つでしょう。型オブジェクトは -:cfunc:`PyObject_\*` 系や :cfunc:`PyType_\*` 系の関数で扱えますが、ほとんど の +:c:func:`PyObject_\*` 系や :c:func:`PyType_\*` 系の関数で扱えますが、ほとん どの Python アプリケーションにとって、さして面白みのある機能を提供しません。 型オブジェクトはオブジェクトがどのように振舞うかを決める基盤ですから、 インタプリタ自体や新たな型を定義する拡張モジュールでは非常に重要な存在で す。 @@ -23,15 +23,15 @@ freefunc, printfunc, getattrfunc, getattrofunc, setattrfunc, setattrofunc, cmpfunc, reprfunc, hashfunc -:ctype:`PyTypeObject` の構造体定義は :file:`Include/object.h` +:c:type:`PyTypeObject` の構造体定義は :file:`Include/object.h` で見つけられるはずです。参照の手間を省くために、ここでは定義を繰り返します: .. literalinclude:: ../includes/typestruct.h -型オブジェクト構造体は :ctype:`PyVarObject` 構造体を拡張したものです。 +型オブジェクト構造体は :c:type:`PyVarObject` 構造体を拡張したものです。 :attr:`ob_size` フィールドは、(通常 class 文が呼び出す :func:`type_new` -で生成される) 動的な型に使います。 :cdata:`PyType_Type` (メタタイプ) +で生成される) 動的な型に使います。 :c:data:`PyType_Type` (メタタイプ) は :attr:`tp_itemsize` を初期化するので注意してください。すなわち、 インスタンス (つまり型オブジェクト) には :attr:`ob_size` フィールドがなければ *なりません* 。 @@ -65,7 +65,7 @@ サブタイプはこのフィールドを継承しません。 .. versionchanged:: 2.5 - このフィールドは以前は :ctype:`int` でした。 + このフィールドは以前は :c:type:`int` でした。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cmember:: PyTypeObject* PyObject.ob_type @@ -77,10 +77,10 @@ Foo_Type.ob_type = &PyType_Type; - 上の操作は、該当する型のいかなるインスタンス生成よりも前にしておかねばな りません。 :cfunc:`PyType_Ready` は + 上の操作は、該当する型のいかなるインスタンス生成よりも前にしておかねばな りません。 :c:func:`PyType_Ready` は :attr:`ob_type` が *NULL* かどうか調べ、 *NULL* の場合には初期化します: Python 2.2 では、 ``&PyType_Type`` にセットします; in Python 2.2.1 およびそれ以降で は基底クラスの :attr:`ob_type` - フィールドに初期化します。 :attr:`ob_type` が非ゼロの場 合、 :cfunc:`PyType_Ready` はこのフィールドを変更しません。 + フィールドに初期化します。 :attr:`ob_type` が非ゼロの場 合、 :c:func:`PyType_Ready` はこのフィールドを変更しません。 Python 2.2 では、サブタイプはこのフィールドを継承しません。 2.2.1 と 2.3 以降では、サブタイプはこのフィールドを継承します。 @@ -131,7 +131,7 @@ になります。また、 :attr:`ob_size` フィールドがあるからといって、必ずし もインスタンスが可変長であることを意味しません (例えば、 リスト型の構造体は固定長のインスタンスになるにもかかわらず、インスタンス にはちゃんと意味を持った :attr:`ob_size` フィールドがあります)。 - 基本サイズには、 :cmacro:`PyObject_HEAD` マクロまた は :cmacro:`PyObject_VAR_HEAD` マクロ + 基本サイズには、 :c:macro:`PyObject_HEAD` マクロまた は :c:macro:`PyObject_VAR_HEAD` マクロ (インスタンス構造体を宣言するのに使ったどちらかのマクロ) で宣言されてい るフィールドが入っています。さらに、 :attr:`_ob_prev` および :attr:`_ob_next` フィールドがある場合、これらのフィールドもサイズに加算 されます。 @@ -155,7 +155,7 @@ や ``Ellipsis`` の場合のように) インスタンスが決してメモリ解放されない型 で ない限り必ず定義しなければなりません。 - デストラクタ関数は、 :cfunc:`Py_DECREF` や :cfunc:`Py_XDECREF` マクロ で、 + デストラクタ関数は、 :c:func:`Py_DECREF` や :c:func:`Py_XDECREF` マクロ で、 操作後の参照カウントがゼロになった際に呼び出されます。呼び出された時点で は、 インスタンスはまだ存在しますが、インスタンスに対する参照は全くない状態で す。 デストラクタ関数はインスタンスが保持している全ての参照を解放し、 @@ -167,10 +167,10 @@ メモリ解放関数 (deallocator) を直接呼び出してもかまいません。オブジェク トの メモリ解放関数は、インスタンスのメモリ確保を行う際に使った関数と同じ ファミリでなければなりません; - インスタンスを :cfunc:`PyObject_New` や :cfunc:`PyObject_VarNew` でメモ リ - 確保した場合には、通常 :cfunc:`PyObject_Del` を使い、 - :cfunc:`PyObject_GC_New` や :cfunc:`PyObject_GC_NewVar` で確保した場合に は - :cfunc:`PyObject_GC_Del` を使います。 + インスタンスを :c:func:`PyObject_New` や :c:func:`PyObject_VarNew` でメ モリ + 確保した場合には、通常 :c:func:`PyObject_Del` を使い、 + :c:func:`PyObject_GC_New` や :c:func:`PyObject_GC_NewVar` で確保した場合 には + :c:func:`PyObject_GC_Del` を使います。 サブタイプはこのフィールドを継承します。 @@ -188,7 +188,7 @@ :attr:`tp_repr` や :attr:`tp_str` と異なる出力を生成するような :attr:`tp_print` は、決して型に実装してはなりません。 - 出力関数は :cfunc:`PyObject_Print` と同じシグネチャ: + 出力関数は :c:func:`PyObject_Print` と同じシグネチャ: ``int tp_print(PyObject *self, FILE *file, int flags)`` で呼び出されま す。 *self* 引数は出力するインスタンスを指します。 *file* 引数は出力先となる標準入出力 (stdio) ファイルです。 @@ -213,7 +213,7 @@ このフィールドは撤廃されています。このフィールドを定義する場 合、 :attr:`tp_getattro` 関数と同じように動作し、属性名は Python 文字列 オブジェクトではなく C 文字列で指定するような関数を指すようにしなければ なりません。シグネチャは - :cfunc:`PyObject_GetAttrString` と同じです。 + :c:func:`PyObject_GetAttrString` と同じです。 このフィールドは :attr:`tp_getattro` と共にサブタイプに継承されます: す なわち、サブタイプの :attr:`tp_getattr` および :attr:`tp_getattro` が共に *NULL* の場合、サブタイプは基底タイプか ら :attr:`tp_getattr` と @@ -226,7 +226,7 @@ このフィールドは撤廃されています。このフィールドを定義する場 合、 :attr:`tp_setattro` 関数と同じように動作し、属性名は Python 文字列 オブジェクトではなく C 文字列で指定するような関数を指すようにしなければ なりません。シグネチャは - :cfunc:`PyObject_SetAttrString` と同じです。 + :c:func:`PyObject_SetAttrString` と同じです。 このフィールドは :attr:`tp_setattro` と共にサブタイプに継承されます: す なわち、サブタイプの :attr:`tp_setattr` および :attr:`tp_setattro` が共に *NULL* の場合、サブタイプは基底タイプか ら :attr:`tp_setattr` と @@ -237,7 +237,7 @@ オプションのフィールドです。ポインタで、三値比較 (three-way comparison) を行う関数を指します。 - シグネチャは :cfunc:`PyObject_Compare` と同じです。この関数は *self* が *other* よりも大きければ ``1``, + シグネチャは :c:func:`PyObject_Compare` と同じです。この関数は *self* が *other* よりも大きければ ``1``, *self* と *other* の値が等しければ ``0``, *self* が *other* より小さけれ ば ``-1`` を返します。 この関数は、比較操作中にエラーが生じた場合、例外状態をセットして ``-1`` を返さねばなりません。 @@ -253,7 +253,7 @@ オプションのフィールドです。ポインタで、組み込み関数 :func:`repr` を実装 している関数を指します。 - シグネチャは :cfunc:`PyObject_Repr` と同じです。この関数は文字列オブジェ クトか Unicode オブジェクトを返さねば + シグネチャは :c:func:`PyObject_Repr` と同じです。この関数は文字列オブジ ェクトか Unicode オブジェクトを返さねば なりません。理想的には、この関数が返す文字列は、適切な環境 で :func:`eval` に渡した場合、同じ値を持つオブジェクトになるような 文字列でなければなりません。不可能な場合には、オブジェクトの型と値から導 出した内容の入った ``'<'`` から始まって ``'>'`` で終わる文字列を返さねばなりません。 @@ -297,17 +297,17 @@ オプションのフィールドです。ポインタで、組み込み関数 :func:`hash` を実装している関数を指します。 - シグネチャは :cfunc:`PyObject_Hash` と同じです。この関数は C の - :ctype:`long` 型の値を返さねばなりません。通常時には ``-1`` + シグネチャは :c:func:`PyObject_Hash` と同じです。この関数は C の + :c:type:`long` 型の値を返さねばなりません。通常時には ``-1`` を戻り値にしてはなりません; ハッシュ値の計算中にエラーが生じた場合、 関数は例外をセットして ``-1`` を返さねばなりません。 - このフィールドは明示的に :cfunc:`PyObject_HashNotImplemented` に設定する ことで、 + このフィールドは明示的に :c:func:`PyObject_HashNotImplemented` に設定す ることで、 親 type からのハッシュメソッドの継承をブロックすることができます。 これは Python レベルでの ``__hash__ = None`` と同等に解釈され、 ``isinstance(o, collections.Hashable)`` が正しく ``False`` を返すように なります。 逆もまた可能であることに注意してください - Python レベルで ``__hash__ = None`` - を設定することで ``tp_hash`` スロット は :cfunc:`PyObject_HashNotImplemented` + を設定することで ``tp_hash`` スロット は :c:func:`PyObject_HashNotImplemented` に設定されます。 このフィールドが設定されていない場合、二つの可能性があります: @@ -325,7 +325,7 @@ オプションのフィールドです。ポインタで、オブジェクトの呼び出しを実装して いる 関数を指します。オブジェクトが呼び出し可能でない場合には *NULL* - にしなければなりません。シグネチャは :cfunc:`PyObject_Call` と同じです。 + にしなければなりません。シグネチャは :c:func:`PyObject_Call` と同じで す。 サブタイプはこのフィールドを継承します。 @@ -334,14 +334,14 @@ オプションのフィールドです。ポインタで、組み込みの演算 :func:`str` を実 装している関数を指します。(:class:`str` が型の一つになったため、 :func:`str` は :class:`str` のコンストラクタを 呼び出す - ことに注意してください。このコンストラクタは実際の処理を行う上 で :cfunc:`PyObject_Str` を呼び出し、さらに - :cfunc:`PyObject_Str` がこのハンドラを呼び出すことになります。) - - シグネチャは :cfunc:`PyObject_Str` と同じです; この関数は文字列オブジェ クトか Unicode オブジェクトを返さねばなりません。 + ことに注意してください。このコンストラクタは実際の処理を行う上 で :c:func:`PyObject_Str` を呼び出し、さらに + :c:func:`PyObject_Str` がこのハンドラを呼び出すことになります。) + + シグネチャは :c:func:`PyObject_Str` と同じです; この関数は文字列オブジェ クトか Unicode オブジェクトを返さねばなりません。 また、この関数はオブジェクトを "分かりやすく (friendly)" 表現した文字列 を返さねばなりません。というのは、この文字列は :keyword:`print` 文で使われることになる表記だからです。 - このフィールドが設定されていない場合、文字列表現を返すために は :cfunc:`PyObject_Repr` が呼び出されます。 + このフィールドが設定されていない場合、文字列表現を返すために は :c:func:`PyObject_Repr` が呼び出されます。 サブタイプはこのフィールドを継承します。 @@ -350,8 +350,8 @@ オプションのフィールドです。ポインタで、 get-attribute を実装している関 数を指します。 - シグネチャは :cfunc:`PyObject_GetAttr` と同じです。 - 対する通常の属性検索を実装している :cfunc:`PyObject_GenericGetAttr` を このフィールドに設定しておくと往々にして便利です。 + シグネチャは :c:func:`PyObject_GetAttr` と同じです。 + 対する通常の属性検索を実装している :c:func:`PyObject_GenericGetAttr` を このフィールドに設定しておくと往々にして便利です。 このフィールドは :attr:`tp_getattr` と共にサブタイプに継承されます: すな わち、サブタイプの :attr:`tp_getattr` および :attr:`tp_getattro` が共に *NULL* の場合、サブタイプは基底タイプか ら :attr:`tp_getattr` と @@ -362,8 +362,8 @@ オプションのフィールドです。ポインタで、 set-attribute を行う関数を指し ます。 - シグネチャは :cfunc:`PyObject_SetAttr` と同じです。 - 対する通常の属性設定を実装している :cfunc:`PyObject_GenericSetAttr` を このフィールドに設定しておくと往々にして便利です。 + シグネチャは :c:func:`PyObject_SetAttr` と同じです。 + 対する通常の属性設定を実装している :c:func:`PyObject_GenericSetAttr` を このフィールドに設定しておくと往々にして便利です。 このフィールドは :attr:`tp_setattr` と共にサブタイプに継承されます: すな わち、サブタイプの :attr:`tp_setattr` および :attr:`tp_setattro` が共に *NULL* の場合、サブタイプは基底タイプか ら :attr:`tp_setattr` と @@ -399,19 +399,19 @@ :attr:`tp_clear` フィールドがサブタイプ内に存在しており、かつ値が *NULL* の場合に基底タイプから値を継承します。 以下のビットマスクは現在定義されているものです; フラグは ``|`` 演算子で 論理和を取って :attr:`tp_flags` フィールドの値にできます。 - :cfunc:`PyType_HasFeature` マクロは型とフラグ値、 *tp* および *f* をと り、 ``tp->tp_flags & f`` + :c:func:`PyType_HasFeature` マクロは型とフラグ値、 *tp* および *f* をと り、 ``tp->tp_flags & f`` が非ゼロかどうか調べます。 .. data:: Py_TPFLAGS_HAVE_GETCHARBUFFER - このビットがセットされていれば、 :attr:`tp_as_buffer` が参照す る :ctype:`PyBufferProcs` 構造体には + このビットがセットされていれば、 :attr:`tp_as_buffer` が参照す る :c:type:`PyBufferProcs` 構造体には :attr:`bf_getcharbuffer` フィールドがあります。 .. data:: Py_TPFLAGS_HAVE_SEQUENCE_IN - このビットがセットされていれば、 :attr:`tp_as_sequence` が参照す る :ctype:`PySequenceMethods` 構造体には + このビットがセットされていれば、 :attr:`tp_as_sequence` が参照す る :c:type:`PySequenceMethods` 構造体には :attr:`sq_contains` フィールドがあります。 @@ -423,21 +423,21 @@ .. data:: Py_TPFLAGS_HAVE_INPLACEOPS - このビットがセットされていれば、 :attr:`tp_as_sequence` が参照す る :ctype:`PySequenceMethods` - 構造体、および :attr:`tp_as_number` が参照す る :ctype:`PyNumberMethods` 構造体には in-place - 演算に関するフィールドが入っています。具体的に言う と、 :ctype:`PyNumberMethods` 構造体はフィールド + このビットがセットされていれば、 :attr:`tp_as_sequence` が参照す る :c:type:`PySequenceMethods` + 構造体、および :attr:`tp_as_number` が参照す る :c:type:`PyNumberMethods` 構造体には in-place + 演算に関するフィールドが入っています。具体的に言う と、 :c:type:`PyNumberMethods` 構造体はフィールド :attr:`nb_inplace_add`, :attr:`nb_inplace_subtract`, :attr:`nb_inplace_multiply`, :attr:`nb_inplace_divide`, :attr:`nb_inplace_remainder`, :attr:`nb_inplace_power`, :attr:`nb_inplace_lshift`, :attr:`nb_inplace_rshift`, :attr:`nb_inplace_and`, :attr:`nb_inplace_xor`,および :attr:`nb_inplace_or` を持つことになり ます; また、 - :ctype:`PySequenceMethods` 構造体はフィール ド :attr:`sq_inplace_concat` および + :c:type:`PySequenceMethods` 構造体はフィール ド :attr:`sq_inplace_concat` および :attr:`sq_inplace_repeat` を持つことになります。 .. data:: Py_TPFLAGS_CHECKTYPES - このビットがセットされていれば、 :attr:`tp_as_number` が参照す る :ctype:`PyNumberMethods` + このビットがセットされていれば、 :attr:`tp_as_number` が参照す る :c:type:`PyNumberMethods` 構造体内で定義されている二項演算子および三項演算子は任意のオブジェク ト型を非演算子にとるようになり、 必要に応じて引数の型変換を行います。このビットがクリアなら、演算子は 全ての引数が現在のオブジェクト型と同じであるよう要求し、 演算の呼び出し側は演算に先立って型変換を行うものと想定します。対象と なる演算子は :attr:`nb_add`, :attr:`nb_subtract`, @@ -490,19 +490,19 @@ .. data:: Py_TPFLAGS_READY - 型オブジェクトが :cfunc:`PyType_Ready` で完全に初期化されるとセットさ れるビットです。 + 型オブジェクトが :c:func:`PyType_Ready` で完全に初期化されるとセット されるビットです。 .. data:: Py_TPFLAGS_READYING - :cfunc:`PyType_Ready` による型オブジェクトの初期化処理中にセットされ るビットです。 + :c:func:`PyType_Ready` による型オブジェクトの初期化処理中にセットされ るビットです。 .. data:: Py_TPFLAGS_HAVE_GC オブジェクトがガベージコレクション (GC) をサポートする場合にセットさ れるビットです。 - このビットがセットされている場合、インスタンス は :cfunc:`PyObject_GC_New` を使って生成し、 - :cfunc:`PyObject_GC_Del` を使って破壊しなければなりません。 + このビットがセットされている場合、インスタンス は :c:func:`PyObject_GC_New` を使って生成し、 + :c:func:`PyObject_GC_Del` を使って破壊しなければなりません。 詳しい情報は :ref:`supporting-cycle-detection` にあります。 このビットはまた、GC に関連するフィールド :attr:`tp_traverse` および :attr:`tp_clear` が型オブジェクト内に存在することを示します; しかし、これらのフィールドは @@ -536,8 +536,8 @@ 場合にのみ使われます。Pythonのガベージコレクションの枠組みに関する詳細 は :ref:`supporting-cycle-detection` にあります。 :attr:`tp_traverse` ポインタは、ガベージコレクタが循環参照を見つけるため に使われます。 :attr:`tp_traverse` - 関数の典型的な実装は、インスタンスの各メンバのうち Pythonオブジェクトに 対して :cfunc:`Py_VISIT` を呼び出します。例えば、次のコードは - :mod:`thread` 拡張モジュールの :cfunc:`local_traverse` 関数になります:: + 関数の典型的な実装は、インスタンスの各メンバのうち Pythonオブジェクトに 対して :c:func:`Py_VISIT` を呼び出します。例えば、次のコードは + :mod:`thread` 拡張モジュールの :c:func:`local_traverse` 関数になります:: static int local_traverse(localobject *self, visitproc visit, void *arg) @@ -548,13 +548,13 @@ return 0; } - :cfunc:`Py_VISIT` が循環参照になる恐れのあるメンバにだけ呼び出されている ことに注目してください。 ``self->key`` + :c:func:`Py_VISIT` が循環参照になる恐れのあるメンバにだけ呼び出されてい ることに注目してください。 ``self->key`` メンバもありますが、それは *NULL* か Python文字列なので、循環参照の一部 になることはありません。 一方、メンバが循環参照の一部になり得ないと判っていても、デバッグ目的で巡 回したい場合があるかもしれないので、 :mod:`gc` モジュールの - :cfunc:`get_reference` 関数は循環参照になり得ないメンバも返します。 - - :cfunc:`Py_VISIT` は :cfunc:`local_traverse` が *visit* と *arg* + :c:func:`get_reference` 関数は循環参照になり得ないメンバも返します。 + + :c:func:`Py_VISIT` は :c:func:`local_traverse` が *visit* と *arg* という決まった名前の引数を持つことを要求します。 このフィールドは :attr:`tp_clear` および :const:`Py_TPFLAGS_HAVE_GC` フ ラグビットと一緒に継承されます: @@ -588,12 +588,12 @@ return 0; } - 参照のクリアはデリケートなので、 :cfunc:`Py_CLEAR` マクロを使うべきです: + 参照のクリアはデリケートなので、 :c:func:`Py_CLEAR` マクロを使うべきで す: ポインタを *NULL* にセットするまで、そのオブジェクトの参照カウントをデク リメントしてはいけません。 参照カウントのデクリメントすると、そのオブジェクトが破棄されるかもしれ ず、 (そのオブジェクトに関連付けられたファイナライザ、弱参照のコールバックに より) 任意のPythonコードの実行を含む後片付け処理が実行されるかもしれないからで す。もしそういったコードが再び *self* を参照することがあれば、すでに 持っていたオブジェクトへのポインタは *NULL* になっているので、 *self* は 所有していたオブジェクトをもう利用できないことを認識できます。 - :cfunc:`Py_CLEAR` マクロはその手続きを安全な順番で実行します。 + :c:func:`Py_CLEAR` マクロはその手続きを安全な順番で実行します。 :attr:`tp_clear` 関数の目的は参照カウントを破壊することなので、Python文 字列や Python整数のような、循環参照になりえないオブジェクトをクリアする必要はあ りません。一方、全部の所有オブジェクトをクリアするようにし、 @@ -627,7 +627,7 @@ *NULL* の場合、サブタイプは基底タイプか ら :attr:`tp_compare`, :attr:`tp_richcompare`, :attr:`tp_hash` の三つを一緒に継承します。 - :attr:`tp_richcompare` および :cfunc:`PyObject_RichCompare` + :attr:`tp_richcompare` および :c:func:`PyObject_RichCompare` 関数の第三引数に使うための定数としては以下が定義されています: +----------------+--------+ @@ -653,8 +653,8 @@ 型のインスタンスが弱参照可能な場合、このフィールドはゼロよりも大きな数に なり、 インスタンス構造体における弱参照リストの先頭を示すオフセットが入ります (GC - ヘッダがある場合には無視します); このオフセット値 は :cfunc:`PyObject_ClearWeakRefs` および - :cfunc:`PyWeakref_\*` 関数が利用します。インスタンス構造体には、 *NULL* に初期化された :ctype:`PyObject\*` 型の + ヘッダがある場合には無視します); このオフセット値 は :c:func:`PyObject_ClearWeakRefs` および + :c:func:`PyWeakref_\*` 関数が利用します。インスタンス構造体には、 *NULL* に初期化された :c:type:`PyObject\*` 型の フィールドが入っていなければなりません。 このフィールドを :attr:`tp_weaklist` と混同しないようにしてくださ い; :attr:`tp_weaklist` @@ -686,7 +686,7 @@ 旧スタイルクラスのインスタンスは :meth:`__iter__` メソッドを定義していな くても この関数を持っています) - この関数は :cfunc:`PyObject_GetIter` と同じシグネチャを持っています。 + この関数は :c:func:`PyObject_GetIter` と同じシグネチャを持っています。 サブタイプはこのフィールドを継承します。 @@ -705,7 +705,7 @@ イテレータ型では、 :attr:`tp_iter` 関数も定義していなければなら ず、 :attr:`tp_iter` は (新たなイテレータインスタンスではなく) イテレータインスタンス自体を返さ ねばなりません。 - この関数のシグネチャは :cfunc:`PyIter_Next` と同じです。 + この関数のシグネチャは :c:func:`PyIter_Next` と同じです。 サブタイプはこのフィールドを継承します。 @@ -715,7 +715,7 @@ .. cmember:: struct PyMethodDef* PyTypeObject.tp_methods - オプションのフィールドです。ポインタで、この型の正規 (regular) のメソッ ドを宣言している :ctype:`PyMethodDef` + オプションのフィールドです。ポインタで、この型の正規 (regular) のメソッ ドを宣言している :c:type:`PyMethodDef` 構造体からなる、 *NULL* で終端された静的な配列を指します。 配列の各要素ごとに、メソッドデスクリプタの入ったエントリが型辞書 (下記 の :attr:`tp_dict` 参照) に追加されます。 @@ -726,7 +726,7 @@ .. cmember:: struct PyMemberDef* PyTypeObject.tp_members オプションのフィールドです。ポインタで、型の正規 (regular) のデータメン バ (フィールドおよびスロット) を - 宣言している :ctype:`PyMemberDef` 構造体からなる、 *NULL* で終端された静 的な配列を指します。 + 宣言している :c:type:`PyMemberDef` 構造体からなる、 *NULL* で終端された 静的な配列を指します。 配列の各要素ごとに、メンバデスクリプタの入ったエントリが型辞書 (下記 の :attr:`tp_dict` 参照) に追加されます。 @@ -736,7 +736,7 @@ .. cmember:: struct PyGetSetDef* PyTypeObject.tp_getset オプションのフィールドです。ポインタで、インスタンスの算出属性 (computed attribute) を - 宣言している :ctype:`PyGetSetDef` 構造体からなる、 *NULL* で終端された静 的な配列を指します。 + 宣言している :c:type:`PyGetSetDef` 構造体からなる、 *NULL* で終端された 静的な配列を指します。 配列の各要素ごとに、getset デスクリプタの入ったエントリが型辞書 (下記 の :attr:`tp_dict` 参照) に追加されます。 @@ -767,10 +767,10 @@ .. cmember:: PyObject* PyTypeObject.tp_dict - 型の辞書は :cfunc:`PyType_Ready` によってこのフィールドに収められます。 - - このフィールドは通常、 :cfunc:`PyType_Ready` を呼び出す前に *NULL* に初 期化しておかねばなりません; あるいは、型の初期属性の入った - 辞書で初期化しておいてもかまいません。 :cfunc:`PyType_Ready` が型をひと たび初期化すると、型の新たな属性をこの辞書に追加できるのは、 + 型の辞書は :c:func:`PyType_Ready` によってこのフィールドに収められます。 + + このフィールドは通常、 :c:func:`PyType_Ready` を呼び出す前に *NULL* に初 期化しておかねばなりません; あるいは、型の初期属性の入った + 辞書で初期化しておいてもかまいません。 :c:func:`PyType_Ready` が型をひと たび初期化すると、型の新たな属性をこの辞書に追加できるのは、 属性が (:meth:`__add__` のような) オーバロード用演算でないときだけです。 サブタイプはこのフィールドを継承しません (が、この辞書内で定義されている 属性は異なるメカニズムで継承されます)。 @@ -805,7 +805,7 @@ .. cmember:: long PyTypeObject.tp_dictoffset 型のインスタンスにインスタンス変数の入った辞書がある場合、このフィールド は非ゼロの値になり、型のインスタンスデータ構造体 - におけるインスタンス変数辞書へのオフセットが入ります; このオフセット値 は :cfunc:`PyObject_GenericGetAttr` が使います。 + におけるインスタンス変数辞書へのオフセットが入ります; このオフセット値 は :c:func:`PyObject_GenericGetAttr` が使います。 このフィールドを :attr:`tp_dict` と混同しないでください; :attr:`tp_dict` は型オブジェクト自体の属性のための辞書です。 @@ -833,7 +833,7 @@ は型オブジェクトから取り出され、 :attr:`ob_size` はインスタンスから取り 出されます。 長整数は符号を記憶するのに :attr:`ob_size` の符号を使うため、 :attr:`ob_size` は絶対値を使います。(この計算を自分で行う必要はまったく ありません; - :cfunc:`_PyObject_GetDictPtr` がやってくれます。) + :c:func:`_PyObject_GetDictPtr` がやってくれます。) サブタイプはこのフィールドを継承しますが、以下の規則があるので読んでくだ さい。 サブタイプはこのオフセット値をオーバライドできます; @@ -901,8 +901,8 @@ で行わねばなりません。 静的なサブタイプはこのフィールドを継承しますが、動的なサブタイプ (:keyword:`class` 文で生成するサブタイプ) の場合は継承しません; - 後者の場合、このフィールドは常に :cfunc:`PyType_GenericAlloc` にセットさ れ、標準のヒープ上メモリ確保戦略が強制されます。 - 静的に定義する型の場合でも、 :cfunc:`PyType_GenericAlloc` を推奨します。 + 後者の場合、このフィールドは常に :c:func:`PyType_GenericAlloc` にセット され、標準のヒープ上メモリ確保戦略が強制されます。 + 静的に定義する型の場合でも、 :c:func:`PyType_GenericAlloc` を推奨しま す。 .. cmember:: newfunc PyTypeObject.tp_new @@ -936,11 +936,11 @@ オプションのフィールドです。ポインタで、インスタンスのメモリ解放関数を指 します。 - この関数のシグネチャは少し変更されています; Python 2.2 および 2.2.1 で は、シグネチャは :ctype:`destructor` :: + この関数のシグネチャは少し変更されています; Python 2.2 および 2.2.1 で は、シグネチャは :c:type:`destructor` :: void tp_free(PyObject *) - でしたが、 Python 2.3 以降では、シグネチャは :ctype:`freefunc`:: + でしたが、 Python 2.3 以降では、シグネチャは :c:type:`freefunc`:: void tp_free(void *) @@ -950,7 +950,7 @@ で適切に対応できるよう変更されました。 静的なサブタイプはこのフィールドを継承しますが、動的なサブタイプ (:keyword:`class` 文で生成するサブタイプ) の場合は継承しません; - 後者の場合、このフィールドには :cfunc:`PyType_GenericAlloc` と :const:`Py_TPFLAGS_HAVE_GC` + 後者の場合、このフィールドには :c:func:`PyType_GenericAlloc` と :const:`Py_TPFLAGS_HAVE_GC` フラグビットの値に対応させるのにふさわしいメモリ解放関数がセットされま す。 @@ -968,7 +968,7 @@ です。 - (上記のような型の例は、型オブジェクト自体です。メタタイ プ :cdata:`PyType_Type` は、型のメモリ確保が静的か動的かを + (上記のような型の例は、型オブジェクト自体です。メタタイ プ :c:data:`PyType_Type` は、型のメモリ確保が静的か動的かを 区別するためにこの関数を定義しています。) サブタイプはこのフィールドを継承します。 (VERSION NOTE: Python 2.2 で は、このフィールドは継承されませんでした。 2.2.1 @@ -990,7 +990,7 @@ 基底クラス群を展開した集合が入っているタプルです。集合は該当する型自体か らはじまり、 :class:`object` で終わります。メソッド解決順 (Method Resolution Order) の順に並んでいます。 - このフィールドは継承されません; フィールドの値は :cfunc:`PyType_Ready` で毎回計算されます。 + このフィールドは継承されません; フィールドの値は :c:func:`PyType_Ready` で毎回計算されます。 .. cmember:: PyObject* PyTypeObject.tp_cache @@ -1110,7 +1110,7 @@ .. cmember:: coercion PyNumberMethods.nb_coerce - この関数は :cfunc:`PyNumber_CoerceEx` から利用され、同じシグネチャを持 ちます。 + この関数は :c:func:`PyNumber_CoerceEx` から利用され、同じシグネチャを 持ちます。 最初の引数は定義された型のオブジェクトを指すポインタでなければなりませ ん。 共通の "大きな" 型への変換が可能であれば、この関数はポインタを変換後の オブジェクトへの新しい参照へ置き換えて、 ``0`` を返します。 @@ -1141,20 +1141,20 @@ .. cmember:: lenfunc PyMappingMethods.mp_length - この関数は :cfunc:`PyMapping_Length` や :cfunc:`PyObject_Size` + この関数は :c:func:`PyMapping_Length` や :c:func:`PyObject_Size` から利用され、それらと同じシグネチャを持っています。 オブジェクトが定義された長さを持たない場合は、このスロットは *NULL* に設定されることがあります。 .. cmember:: binaryfunc PyMappingMethods.mp_subscript - この関数は :cfunc:`PyObject_GetItem` から利用され、同じシグネチャを持っ ています。 - このスロットは :cfunc:`PyMapping_Check` が ``1`` を返すためには + この関数は :c:func:`PyObject_GetItem` から利用され、同じシグネチャを持っ ています。 + このスロットは :c:func:`PyMapping_Check` が ``1`` を返すためには 必要で、そうでなければ *NULL* の場合があります。 .. cmember:: objobjargproc PyMappingMethods.mp_ass_subscript - この関数は :cfunc:`PyObject_SetItem` から利用され、同じシグネチャを持っ ています。 + この関数は :c:func:`PyObject_SetItem` から利用され、同じシグネチャを持っ ています。 もしこのスロットが *NULL* なら、このオブジェクトはアイテムの代入をサポー トしません。 @@ -1172,28 +1172,28 @@ .. cmember:: lenfunc PySequenceMethods.sq_length - この関数は :cfunc:`PySequence_Size` や :cfunc:`PyObject_Size` + この関数は :c:func:`PySequence_Size` や :c:func:`PyObject_Size` から利用され、それらと同じシグネチャを持っています。 .. cmember:: binaryfunc PySequenceMethods.sq_concat - この関数は :cfunc:`PySequence_Concat` + この関数は :c:func:`PySequence_Concat` から利用され、同じシグネチャを持っています。 また、 ``+`` 演算からも、 :attr:`tp_as_number.nb_add` スロットによる 数値加算を試したあとに利用されます。 .. cmember:: ssizeargfunc PySequenceMethods.sq_repeat - この関数は :cfunc:`PySequence_Repeat` + この関数は :c:func:`PySequence_Repeat` から利用され、同じシグネチャを持っています。 また、 ``*`` 演算からも、 :attr:`tp_as_number.nb_mul` スロットによる 数値乗算を試したあとに利用されます。 .. cmember:: ssizeargfunc PySequenceMethods.sq_item - この関数は :cfunc:`PySequence_GetItem` + この関数は :c:func:`PySequence_GetItem` から利用され、同じシグネチャを持っています。 - このスロットは :cfunc:`PySequence_Check` が ``1`` を返すためには埋めなけ ればならず、 + このスロットは :c:func:`PySequence_Check` が ``1`` を返すためには埋めな ければならず、 それ以外の場合は *NULL* の可能性があります。 負のインデックスは次のように処理されます: :attr:`sq_length` スロットが @@ -1203,27 +1203,27 @@ .. cmember:: ssizeobjargproc PySequenceMethods.sq_ass_item - この関数は :cfunc:`PySequence_SetItem` + この関数は :c:func:`PySequence_SetItem` から利用され、同じシグネチャを持っています。 このスロットはオブジェクトが要素の代入をサポートしていない場合は *NULL* かもしれません。 .. cmember:: objobjproc PySequenceMethods.sq_contains - この関数は :cfunc:`PySequence_Contains` + この関数は :c:func:`PySequence_Contains` から利用され、同じシグネチャを持っています。 - このスロットは *NULL* の場合があり、その時 :cfunc:`PySequence_Contains` + このスロットは *NULL* の場合があり、その時 :c:func:`PySequence_Contains` はシンプルにマッチするオブジェクトを見つけるまでシーケンスを巡回します。 .. cmember:: binaryfunc PySequenceMethods.sq_inplace_concat - この関数は :cfunc:`PySequence_InPlaceConcat` + この関数は :c:func:`PySequence_InPlaceConcat` から利用され、同じシグネチャを持っています。 この関数は最初のオペランドを修正してそれを返すべきです。 .. cmember:: ssizeargfunc PySequenceMethods.sq_inplace_repeat - この関数は :cfunc:`PySequence_InPlaceRepeat` + この関数は :c:func:`PySequence_InPlaceRepeat` から利用され、同じシグネチャを持っています。 この関数は最初のオペランドを修正してそれを返すべきです。 @@ -1243,14 +1243,14 @@ 各チャンクはポインタ/データ長からなるペアで指定します。チャンクはセグメント (:dfn:`segment`) と呼ばれ、 メモリ内に不連続的に配置されるものと想定されています。 -バッファインタフェースを利用できるようにしたくないオブジェクトで は、 :ctype:`PyTypeObject` 構造体の +バッファインタフェースを利用できるようにしたくないオブジェクトで は、 :c:type:`PyTypeObject` 構造体の :attr:`tp_as_buffer` メンバを *NULL* にしなくてはなりません。利用できるよう にする場合、 :attr:`tp_as_buffer` -は :ctype:`PyBufferProcs` 構造体を指さねばなりません。 +は :c:type:`PyBufferProcs` 構造体を指さねばなりません。 .. note:: - :ctype:`PyTypeObject` 構造体の :attr:`tp_flags` メンバの値を ``0`` でな く - :const:`Py_TPFLAGS_DEFAULT` にしておくことがとても重要です。この設定 は、 :ctype:`PyBufferProcs` 構造体に + :c:type:`PyTypeObject` 構造体の :attr:`tp_flags` メンバの値を ``0`` でな く + :const:`Py_TPFLAGS_DEFAULT` にしておくことがとても重要です。この設定 は、 :c:type:`PyBufferProcs` 構造体に :attr:`bf_getcharbuffer` スロットが入っていることを Python ランタイムに 教えます。 Python の古いバージョンには :attr:`bf_getcharbuffer` メンバが存在しないので、古い拡張モジュールを使 おうとしている新しいバージョンの Python インタプリタは、このメンバがあるかどうかテストしてから使えるようにする必 要があるのです。 @@ -1260,23 +1260,23 @@ バッファプロトコルの実装を定義している関数群へのポインタを保持するのに使 われる構造体です。 - 最初のスロットは :attr:`bf_getreadbuffer` で、 :ctype:`getreadbufferproc` 型です。このスロットが + 最初のスロットは :attr:`bf_getreadbuffer` で、 :c:type:`getreadbufferproc` 型です。このスロットが *NULL* の場合、オブジェクトは内部データの読み出しをサポートしません。そ のような仕様には意味がないので、 実装を行う側はこのスロットに値を埋めるはずですが、呼び出し側では非 *NULL* の値かどうかきちんと調べておくべきです。 - 次のスロットは :attr:`bf_getwritebuffer` で、 :ctype:`getwritebufferproc` + 次のスロットは :attr:`bf_getwritebuffer` で、 :c:type:`getwritebufferproc` 型です。オブジェクトが返すバッファに対して書き込みを許可しない場合はこの スロットを *NULL* にできます。 - 第三のスロットは :attr:`bf_getsegcount` で、 :ctype:`getsegcountproc` 型 です。このスロットは *NULL* - であってはならず、オブジェクトにいくつセグメントが入っているかを呼び出し 側に教えるために使われます。 :ctype:`PyString_Type` や - :ctype:`PyBuffer_Type` オブジェクトのような単純なオブジェクトには単一の セグメントしか入っていません。 + 第三のスロットは :attr:`bf_getsegcount` で、 :c:type:`getsegcountproc` 型です。このスロットは *NULL* + であってはならず、オブジェクトにいくつセグメントが入っているかを呼び出し 側に教えるために使われます。 :c:type:`PyString_Type` や + :c:type:`PyBuffer_Type` オブジェクトのような単純なオブジェクトには単一の セグメントしか入っていません。 .. index:: single: PyType_HasFeature() - 最後のスロットは :attr:`bf_getcharbuffer` で、 :ctype:`getcharbufferproc` です。オブジェクトの - :ctype:`PyTypeObject` 構造体における :attr:`tp_flags` フィールドに、 + 最後のスロットは :attr:`bf_getcharbuffer` で、 :c:type:`getcharbufferproc` です。オブジェクトの + :c:type:`PyTypeObject` 構造体における :attr:`tp_flags` フィールドに、 :const:`Py_TPFLAGS_HAVE_GETCHARBUFFER` ビットフラグがセットされている場 合にのみ、このスロットが存在することになります。 - このスロットの使用に先立って、呼び出し側は :cfunc:`PyType_HasFeature` を 使ってスロットが存在するか調べねばなりません。 + このスロットの使用に先立って、呼び出し側は :c:func:`PyType_HasFeature` を使ってスロットが存在するか調べねばなりません。 フラグが立っていても、 :attr:`bf_getcharbuffer` は *NULL* のときもあ り、 *NULL* はオブジェクトの内容を *8 ビット文字列* として利用できないことを示します。このスロットに入る関数も、オブジェクト の内容を 8 ビット文字列に 変換できない場合に例外を送出することがあります。例えば、オブジェクトが浮 動小数点数を保持するように設定されたアレイの場合、呼び出し側が ======================================= --- /c-api/unicode.rst Mon Nov 29 20:10:21 2010 +++ /c-api/unicode.rst Wed Mar 30 18:55:11 2011 @@ -19,13 +19,13 @@ .. ctype:: Py_UNICODE この型はUnicode序数(Unicode ordinal)を保持するための基礎単位として、 Pythonが内部的に使います。 - Pythonのデフォルトのビルドでは、 :ctype:`Py_UNICODE` として16-bit型を利 用し、 Unicodeの値を内部ではUCS-2で保持します。 + Pythonのデフォルトのビルドでは、 :c:type:`Py_UNICODE` として16-bit型を利 用し、 Unicodeの値を内部ではUCS-2で保持します。 UCS4版のPythonをビルドすることもできます。(最近の多くのLinuxディストリビ ューションでは UCS4版のPythonがついてきます) - UCS4版ビルドでは :ctype:`Py_UNICODE` に32-bit型を利用し、内部では Unicode データをUCS4で保持します。 - :ctype:`wchar_t` が利用できて、PythonのUnicodeに関するビルドオプションと - 一致するときは、 :ctype:`Py_UNICODE` は :ctype:`wchar_t` をtypedefでエイ リアス - され、ネイティブプラットフォームに対する互換性を高めます。それ以外のすべ てのプラットフォームでは、 :ctype:`Py_UNICODE` は - :ctype:`unsigned short` (UCS2) か :ctype:`unsigned long` (UCS4) の + UCS4版ビルドでは :c:type:`Py_UNICODE` に32-bit型を利用し、内部では Unicode データをUCS4で保持します。 + :c:type:`wchar_t` が利用できて、PythonのUnicodeに関するビルドオプション と + 一致するときは、 :c:type:`Py_UNICODE` は :c:type:`wchar_t` をtypedefでエ イリアス + され、ネイティブプラットフォームに対する互換性を高めます。それ以外のすべ てのプラットフォームでは、 :c:type:`Py_UNICODE` は + :c:type:`unsigned short` (UCS2) か :c:type:`unsigned long` (UCS4) の typedefによるエイリアスになります。 UCS2とUCS4のPythonビルドの間にはバイナリ互換性がないことに注意してくださ い。拡張やインタフェースを書くときには、このことを覚えておいてください。 @@ -33,12 +33,12 @@ .. ctype:: PyUnicodeObject - この :ctype:`PyObject` のサブタイプは Unicode オブジェクトを表現します。 + この :c:type:`PyObject` のサブタイプは Unicode オブジェクトを表現しま す。 .. cvar:: PyTypeObject PyUnicode_Type - この :ctype:`PyTypeObject` のインスタンスは Python の Unicode 型を表現し ます。 + この :c:type:`PyTypeObject` のインスタンスは Python の Unicode 型を表現 します。 Pythonレイヤにおける ``unicode`` や ``types.UnicodeType`` と同じオブジェ クトです。 以下の API は実際には C マクロで、Unicode オブジェクト内部の読み出し専用 データに対するチェックやアクセスを高速に行います: @@ -61,30 +61,30 @@ .. cfunction:: Py_ssize_t PyUnicode_GET_SIZE(PyObject *o) - オブジェクトのサイズを返します。 *o* は :ctype:`PyUnicodeObject` でなけ ればなりません (チェックはしません)。 + オブジェクトのサイズを返します。 *o* は :c:type:`PyUnicodeObject` でなけ ればなりません (チェックはしません)。 .. versionchanged:: 2.5 - これらの関数は以前は :ctype:`int` を返していました。 + これらの関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: Py_ssize_t PyUnicode_GET_DATA_SIZE(PyObject *o) - オブジェクトの内部バッファのサイズをバイト数で返します。 *o* は :ctype:`PyUnicodeObject` でなければなりません + オブジェクトの内部バッファのサイズをバイト数で返します。 *o* は :c:type:`PyUnicodeObject` でなければなりません (チェックはしません)。 .. versionchanged:: 2.5 - これらの関数は以前は :ctype:`int` を返していました。 + これらの関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: Py_UNICODE* PyUnicode_AS_UNICODE(PyObject *o) - オブジェクト内部の :ctype:`Py_UNICODE` バッファへのポインタを返しま す。 *o* は :ctype:`PyUnicodeObject` + オブジェクト内部の :c:type:`Py_UNICODE` バッファへのポインタを返しま す。 *o* は :c:type:`PyUnicodeObject` でなければなりません (チェックはしません)。 .. cfunction:: const char* PyUnicode_AS_DATA(PyObject *o) - オブジェクト内部バッファへのポインタを返します。 *o* は :ctype:`PyUnicodeObject` でなければなりません + オブジェクト内部バッファへのポインタを返します。 *o* は :c:type:`PyUnicodeObject` でなければなりません (チェックはしません)。 .. cfunction:: int PyUnicode_ClearFreeList() @@ -181,7 +181,7 @@ .. cfunction:: double Py_UNICODE_TONUMERIC(Py_UNICODE ch) - *ch* を :ctype:`double` に変換したものを返します。不可能ならば ``-1.0`` を返します。このマクロは例外を送出しません。 + *ch* を :c:type:`double` に変換したものを返します。不可能ならば ``-1.0`` を返します。このマクロは例外を送出しません。 Plain Py_UNICODE @@ -198,12 +198,12 @@ オブジェクトを変更してよいのは *u* が *NULL* のときだけです。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: Py_UNICODE* PyUnicode_AsUnicode(PyObject *unicode) - Unicode オブジェクトの内部バッファ :ctype:`Py_UNICODE` に対する読み出し 専用のポインタを返します。 *unicode* が + Unicode オブジェクトの内部バッファ :c:type:`Py_UNICODE` に対する読み出し 専用のポインタを返します。 *unicode* が Unicode オブジェクトでなければ *NULL* を返します。 @@ -212,7 +212,7 @@ Unicode オブジェクトの長さを返します。 .. versionchanged:: 2.5 - これらの関数は以前は :ctype:`int` を返していました。 + これらの関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_FromEncodedObject(PyObject *obj, const char *encoding, const char *errors) @@ -234,9 +234,9 @@ ``PyUnicode_FromEncodedObject(obj, NULL, "strict")`` を行うショートカッ トで、インタプリタは Unicode への型強制が必要な際に常にこの関数を使います。 -プラットフォームで :ctype:`wchar_t` がサポートされていて、かつ wchar.h が提 供されている場合、Python は以下の関数を使って -:ctype:`wchar_t` に対するインタフェースを確立することがあります。このサポー トは、Python 自体の :ctype:`Py_UNICODE` -型がシステムの :ctype:`wchar_t` と同一の場合に最適化をもたらします。 +プラットフォームで :c:type:`wchar_t` がサポートされていて、かつ wchar.h が 提供されている場合、Python は以下の関数を使って +:c:type:`wchar_t` に対するインタフェースを確立することがあります。このサ ポートは、Python 自体の :c:type:`Py_UNICODE` +型がシステムの :c:type:`wchar_t` と同一の場合に最適化をもたらします。 wchar_t サポート """"""""""""""""" @@ -245,22 +245,22 @@ .. cfunction:: PyObject* PyUnicode_FromWideChar(const wchar_t *w, Py_ssize_t size) - *size* の :ctype:`wchar_t` バッファ *w* から Unicode オブジェクトを生成 します。失敗すると *NULL* を返します。 + *size* の :c:type:`wchar_t` バッファ *w* から Unicode オブジェクトを生成 します。失敗すると *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: Py_ssize_t PyUnicode_AsWideChar(PyUnicodeObject *unicode, wchar_t *w, Py_ssize_t size) - Unicode オブジェクトの内容を :ctype:`wchar_t` バッファ *w* にコピーしま す。最大で *size* 個の - :ctype:`wchar_t` 文字を (末尾の 0-終端文字を除いて) コピーします。コピー した :ctype:`wchar_t` - 文字の個数を返します。エラーの時には -1 を返します。 :ctype:`wchar_t` 文 字列は 0-終端されている場合も、されていない場合も - あります。関数の呼び出し手の責任で、アプリケーションの必要に応じ て :ctype:`wchar_t` 文字列を 0-終端してください。 + Unicode オブジェクトの内容を :c:type:`wchar_t` バッファ *w* にコピーしま す。最大で *size* 個の + :c:type:`wchar_t` 文字を (末尾の 0-終端文字を除いて) コピーします。コ ピーした :c:type:`wchar_t` + 文字の個数を返します。エラーの時には -1 を返します。 :c:type:`wchar_t` 文字列は 0-終端されている場合も、されていない場合も + あります。関数の呼び出し手の責任で、アプリケーションの必要に応じ て :c:type:`wchar_t` 文字列を 0-終端してください。 .. versionchanged:: 2.5 - この関数は以前は :ctype:`int` を返していました。 + この関数は以前は :c:type:`int` を返していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -276,7 +276,7 @@ オブジェクトコンストラクタである :func:`unicode` における同名のパラメタと同 じセマンティクスになっています。 *encoding* を *NULL* にすると、デフォルトエンコーディングである ASCIIを使い ます。ファイルシステムに関する関数の呼び出し -では、ファイル名に対するエンコーディングとし て :cdata:`Py_FileSystemDefaultEncoding` を使わねばなりません。 +では、ファイル名に対するエンコーディングとし て :c:data:`Py_FileSystemDefaultEncoding` を使わねばなりません。 この変数は読み出し専用の変数として扱わねばなりません: この変数は、あるシス テムによっては静的な文字列に対するポインタで あったり、また別のシステムでは、(アプリケーションが setlocale を読んだとき などに) 変わったりもします。 @@ -299,18 +299,18 @@ Python の codec レジストリを使って行います。codec が例外を送出した場合に は *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_Encode(const Py_UNICODE *s, Py_ssize_t size, const char *encoding, const char *errors) - *size* で指定されたサイズの :ctype:`Py_UNICODE` バッファをエンコードし た Python 文字列オブジェクトを返します。 + *size* で指定されたサイズの :c:type:`Py_UNICODE` バッファをエンコードし た Python 文字列オブジェクトを返します。 *encoding* および *errors* は Unicode 型の :meth:`encode` メソッドに与え る同名のパラメタと 同じ意味を持ちます。使用する codec の検索は、 Python の codec レジストリ を使って行います。codec が例外を送出した場合には *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_AsEncodedString(PyObject *unicode, const char *encoding, const char *errors) @@ -332,28 +332,28 @@ *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_DecodeUTF8Stateful(const char *s, Py_ssize_t size, const char *errors, Py_ssize_t *consumed) - *consumed* が *NULL* の場合、 :cfunc:`PyUnicode_DecodeUTF8` と同じように 動作します。 *consumed* が - *NULL* でない場合、 :cfunc:`PyUnicode_DecodeUTF8Stateful` は末尾の不完全 な UTF-8 バイト列 + *consumed* が *NULL* の場合、 :c:func:`PyUnicode_DecodeUTF8` と同じよう に動作します。 *consumed* が + *NULL* でない場合、 :c:func:`PyUnicode_DecodeUTF8Stateful` は末尾の不完 全な UTF-8 バイト列 をエラーとみなしません。これらのバイト列はデコードされず、デコードされた バイト数を *consumed* に返します。 .. versionadded:: 2.4 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_EncodeUTF8(const Py_UNICODE *s, Py_ssize_t size, const char *errors) - *size* で指定された長さを持つ :ctype:`Py_UNICODE` 型バッファを UTF-8 で エンコードし、 Python + *size* で指定された長さを持つ :c:type:`Py_UNICODE` 型バッファを UTF-8 で エンコードし、 Python 文字列オブジェクトにして返します。 codec が例外を送出した場合には *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_AsUTF8String(PyObject *unicode) @@ -397,8 +397,8 @@ .. cfunction:: PyObject* PyUnicode_DecodeUTF32Stateful(const char *s, Py_ssize_t size, const char *errors, int *byteorder, Py_ssize_t *consumed) - *consumed* が *NULL* のとき、 :cfunc:`PyUnicode_DecodeUTF32` と同じよう に振る舞います。 - *consumed* が非 *NULL* のとき、 :cfunc:`PyUnicode_DecodeUTF32Stateful` は末尾の + *consumed* が *NULL* のとき、 :c:func:`PyUnicode_DecodeUTF32` と同じよう に振る舞います。 + *consumed* が非 *NULL* のとき、 :c:func:`PyUnicode_DecodeUTF32Stateful` は末尾の 不完全な(4で割り切れない数などの)UTF-32バイト列をエラーとして扱いませ ん。 末尾の不完全なバイト列はデコードされず、デコードされたバイトすが *consumed* に格納されます。 @@ -470,21 +470,21 @@ codec が例外を送出した場合には *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_DecodeUTF16Stateful(const char *s, Py_ssize_t size, const char *errors, int *byteorder, Py_ssize_t *consumed) - *consumed* が *NULL* の場合、 :cfunc:`PyUnicode_DecodeUTF16` と同じよう に動作します。 *consumed* が - *NULL* でない場合、 :cfunc:`PyUnicode_DecodeUTF16Stateful` は末尾の不完 全な UTF-16 バイト列 + *consumed* が *NULL* の場合、 :c:func:`PyUnicode_DecodeUTF16` と同じよう に動作します。 *consumed* が + *NULL* でない場合、 :c:func:`PyUnicode_DecodeUTF16Stateful` は末尾の不完 全な UTF-16 バイト列 (奇数長のバイト列や分割されたサロゲートペア) をエラーとみなしません。こ れらのバイト列はデコードされず、デコードされたバイト数を *consumed* に返します。 .. versionadded:: 2.4 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -500,13 +500,13 @@ byteorder が ``0`` の場合、出力結果となる文字列は常に Unicode BOM マーカ (U+FEFF) で始まります。それ以外のモードでは、 BOM マーカを頭につけませ ん。 - *Py_UNICODE_WIDE* が定義されている場合、単一の :ctype:`Py_UNICODE` 値は サロゲートペアとして表現されることがあります。 - *Py_UNICODE_WIDE* が定義されていなければ、各 :ctype:`Py_UNICODE` 値は UCS-2 文字として表現されます。 + *Py_UNICODE_WIDE* が定義されている場合、単一の :c:type:`Py_UNICODE` 値は サロゲートペアとして表現されることがあります。 + *Py_UNICODE_WIDE* が定義されていなければ、各 :c:type:`Py_UNICODE` 値は UCS-2 文字として表現されます。 codec が例外を送出した場合には *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_AsUTF16String(PyObject *unicode) @@ -528,14 +528,14 @@ .. cfunction:: PyObject* PyUnicode_DecodeUTF8Stateful(const char *s, Py_ssize_t size, const char *errors, Py_ssize_t *consumed) - *consumed* が *NULL* のとき、 :cfunc:`PyUnicode_DecodeUTF7` と同じように 動作します。 + *consumed* が *NULL* のとき、 :c:func:`PyUnicode_DecodeUTF7` と同じよう に動作します。 *consumed* が非 *NULL* のとき、末尾の不完全な UTF-7 base-64 部分をエラー としません。 不完全な部分のバイト列はデコードせずに、デコードしたバイト数を *consumed* に格納します。 .. cfunction:: PyObject* PyUnicode_EncodeUTF7(const Py_UNICODE *s, Py_ssize_t size, int base64SetO, int base64WhiteSpace, const char *errors) - 与えられたサイズの :ctype:`Py_UNICODE` バッファを UTF-7 でエンコードし て、 + 与えられたサイズの :c:type:`Py_UNICODE` バッファを UTF-7 でエンコードし て、 Python の bytes オブジェクトとして返します。 コーデックが例外を発生させたときは *NULL* を返します。 @@ -561,17 +561,17 @@ が例外を送出した場合には *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_EncodeUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size) - *size* で指定された長さを持つ :ctype:`Py_UNICODE` 型バッファを Unicode-Escape でエンコードし、 Python + *size* で指定された長さを持つ :c:type:`Py_UNICODE` 型バッファを Unicode-Escape でエンコードし、 Python 文字列オブジェクトにして返します。 codec が例外を送出した場合には *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -593,17 +593,17 @@ が例外を送出した場合には *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_EncodeRawUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size, const char *errors) - *size* で指定された長さを持つ :ctype:`Py_UNICODE` 型バッファを Raw-Unicode-Escape でエンコードし、 Python + *size* で指定された長さを持つ :c:type:`Py_UNICODE` 型バッファを Raw-Unicode-Escape でエンコードし、 Python 文字列オブジェクトにして返します。 codec が例外を送出した場合には *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -625,17 +625,17 @@ *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_EncodeLatin1(const Py_UNICODE *s, Py_ssize_t size, const char *errors) - *size* で指定された長さを持つ :ctype:`Py_UNICODE` 型バッファを Latin-1 でエンコードし、 Python + *size* で指定された長さを持つ :c:type:`Py_UNICODE` 型バッファを Latin-1 でエンコードし、 Python 文字列オブジェクトにして返します。 codec が例外を送出した場合には *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -656,17 +656,17 @@ *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_EncodeASCII(const Py_UNICODE *s, Py_ssize_t size, const char *errors) - *size* で指定された長さを持つ :ctype:`Py_UNICODE` 型バッファを ASCII で エンコードし、 Python + *size* で指定された長さを持つ :c:type:`Py_UNICODE` 型バッファを ASCII で エンコードし、 Python 文字列オブジェクトにして返します。 codec が例外を送出した場合には *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -714,16 +714,16 @@ mapping引数としてunicodeが使えるようになりました. .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_EncodeCharmap(const Py_UNICODE *s, Py_ssize_t size, PyObject *mapping, const char *errors) - *size* で指定された長さを持つ :ctype:`Py_UNICODE` 型バッファを *mapping* に指定されたオブジェクトを使ってエンコードし、 + *size* で指定された長さを持つ :c:type:`Py_UNICODE` 型バッファを *mapping* に指定されたオブジェクトを使ってエンコードし、 Python 文字列オブジェクトにして返します。 codec が例外を送出した場合に は *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_AsCharmapString(PyObject *unicode, PyObject *mapping) @@ -736,7 +736,7 @@ .. cfunction:: PyObject* PyUnicode_TranslateCharmap(const Py_UNICODE *s, Py_ssize_t size, PyObject *table, const char *errors) - *で* 指定された長さを持つ :ctype:`Py_UNICODE` バッファを、文字変換マッ プ *table* を適用して変換し、変換結果を Unicode + *で* 指定された長さを持つ :c:type:`Py_UNICODE` バッファを、文字変換マッ プ *table* を適用して変換し、変換結果を Unicode オブジェクトで返します。codec が例外を発行した場合には *NULL* を返しま す。 対応付けを行う *table* は、 Unicode 序数を表す整数を Unicode 序数を表す 整数または ``None`` に対応付けます。 @@ -747,7 +747,7 @@ 変換は行わず、そのままコピーします。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 MBCS codecs for Windows @@ -765,14 +765,14 @@ *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_DecodeMBCSStateful(const char *s, int size, const char *errors, int *consumed) - *consumed* が *NULL* のとき、 :cfunc:`PyUnicode_DecodeMBCS` と同じ動作を します。 - *consumed* が *NULL* でないとき、 :cfunc:`PyUnicode_DecodeMBCSStateful` は + *consumed* が *NULL* のとき、 :c:func:`PyUnicode_DecodeMBCS` と同じ動作 をします。 + *consumed* が *NULL* でないと き、 :c:func:`PyUnicode_DecodeMBCSStateful` は 文字列の最後にあるマルチバイト文字の前半バイトをデコードせず、 *consumed* にデコードしたバイト数を格納します。 .. versionadded:: 2.5 @@ -780,11 +780,11 @@ .. cfunction:: PyObject* PyUnicode_EncodeMBCS(const Py_UNICODE *s, Py_ssize_t size, const char *errors) - *size* で指定された長さを持つ :ctype:`Py_UNICODE` 型バッファを MBCS でエ ンコードし、 Python + *size* で指定された長さを持つ :c:type:`Py_UNICODE` 型バッファを MBCS で エンコードし、 Python 文字列オブジェクトにして返します。 codec が例外を送出した場合には *NULL* を返します。 .. versionchanged:: 2.5 - この関数は以前は *size* の型に :ctype:`int` を利用していました。 + この関数は以前は *size* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -820,7 +820,7 @@ が負ならば分割数に制限を設けません。分割結果のリスト内には分割文字は含み ません。 .. versionchanged:: 2.5 - この関数は以前は *maxsplit* の型に :ctype:`int` を利用していました。 + この関数は以前は *maxsplit* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 .. cfunction:: PyObject* PyUnicode_Splitlines(PyObject *s, int keepend) @@ -856,7 +856,7 @@ を返します。 .. versionchanged:: 2.5 - この関数は以前は *start*, *end* の型に :ctype:`int` を利用していまし た。 + この関数は以前は *start*, *end* の型に :c:type:`int` を利用していまし た。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -867,7 +867,7 @@ インデクスです; 戻り値 ``-1`` はマッチが見つからなかったことを表し、 ``-2`` はエラーが発生して例外情報が設定されていることを表します。 .. versionchanged:: 2.5 - この関数は以前は *start*, *end* の型に :ctype:`int` を利用していまし た。 + この関数は以前は *start*, *end* の型に :c:type:`int` を利用していまし た。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -876,7 +876,7 @@ ``str[start:end]`` に *substr* が重複することなく出現する回数を返しま す。エラーが発生した場合には ``-1`` を返します。 .. versionchanged:: 2.5 - この関数は以前は *start*, *end* と戻り値の型に :ctype:`int` を利用し ていました。 + この関数は以前は *start*, *end* と戻り値の型に :c:type:`int` を利用し ていました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -886,7 +886,7 @@ 返します。 *maxcount* == -1 にすると、全ての *substr* を置換します。 .. versionchanged:: 2.5 - この関数は以前は *maxcount* の型に :ctype:`int` を利用していました。 + この関数は以前は *maxcount* の型に :c:type:`int` を利用していました。 この変更により、 64bit システムを正しくサポートするには修正が必要にな ります。 @@ -902,7 +902,7 @@ * ``NULL`` を、例外が発生したときに返します。 * :const:`Py_True` もしくは :const:`Py_False` を、正しく比較できた時に返 します。 * :const:`Py_NotImplemented` を、leftとrightがのどちらかに対する - :cfunc:`PyUnicode_FromObject` が失敗したときに返します。(原文: in case the type combination is + :c:func:`PyUnicode_FromObject` が失敗したときに返します。(原文: in case the type combination is unknown) .. 訳注: 原文が分かりにくいので翻訳者が解説しました。 ======================================= --- /c-api/veryhigh.rst Sun Nov 28 08:46:26 2010 +++ /c-api/veryhigh.rst Wed Mar 30 18:55:11 2011 @@ -13,17 +13,17 @@ 使用できる開始記号は :const:`Py_eval_input` と :const:`Py_file_input` 、 :const:`Py_single_input` です。開始期号の説明はこれらを引数として取る関数の 後にあります。 -これらの関数のいくつかが :ctype:`FILE\*` 引数をとることにも注意してくださ い。 -注意深く扱う必要がある特別な問題の1つは、異なるCライブラリの :ctype:`FILE` 構造体は異なっていて互換性がない可能性があるということです。 +これらの関数のいくつかが :c:type:`FILE\*` 引数をとることにも注意してくださ い。 +注意深く扱う必要がある特別な問題の1つは、異なるCライブラリ の :c:type:`FILE` 構造体は異なっていて互換性がない可能性があるということで す。 実際に(少なくとも)Windowsでは、動的リンクされる拡張が異なるライブラリを -使うことが可能であり、したがって、 :ctype:`FILE\*` 引数がPythonランタイムが +使うことが可能であり、したがって、 :c:type:`FILE\*` 引数がPythonランタイム が 使っているライブラリと同じライブラリによって作成されたことが確かならば、単 にこれらの関数へ渡すだけということに注意すべきです。 .. cfunction:: int Py_Main(int argc, char **argv) 標準インタプリタのためのメインプログラム。Pythonを組み込むプログラムのた めにこれを利用できるようにしています。 - *argc* と *argv* 引数をCプログラムの :cfunc:`main` 関数へ渡されるものと まったく同じに作成すべきです。 + *argc* と *argv* 引数をCプログラムの :c:func:`main` 関数へ渡されるものと まったく同じに作成すべきです。 引数リストが変更される可能性があるという点に注意することは重要です。 (し かし、引数リストが指している文字列の内容は変更されません)。 戻り値は :func:`sys.exit` 関数へ渡される整数でしょう。例外が原因でインタ プリタが終了した場合は ``1`` 、あるいは、 引数リストが有効なPythonコマンドラインになっていない場合は ``2`` です。 @@ -33,31 +33,31 @@ .. cfunction:: int PyRun_AnyFile(FILE *fp, const char *filename) - 下記の :cfunc:`PyRun_AnyFileExFlags` の *closeit* を ``0`` に、 *flags* を + 下記の :c:func:`PyRun_AnyFileExFlags` の *closeit* を ``0`` に、 *flags* を *NULL* にして単純化したインタフェースです。 .. cfunction:: int PyRun_AnyFileFlags(FILE *fp, const char *filename, PyCompilerFlags *flags) - 下記の :cfunc:`PyRun_AnyFileExFlags` の *closeit* を ``0`` にして単純化 したインタフェースです。 + 下記の :c:func:`PyRun_AnyFileExFlags` の *closeit* を ``0`` にして単純化 したインタフェースです。 .. cfunction:: int PyRun_AnyFileEx(FILE *fp, const char *filename, int closeit) - 下記の :cfunc:`PyRun_AnyFileExFlags` の *flags* を *NULL* にして単純化し たインタフェースです。 + 下記の :c:func:`PyRun_AnyFileExFlags` の *flags* を *NULL* にして単純化 したインタフェースです。 .. cfunction:: int PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags) *fp* が対話的デバイス(コンソールや端末入力あるいはUnix仮想端末)と関連づ けられたファイルを参照しているならば、 - :cfunc:`PyRun_InteractiveLoop` の値を返します。それ以外の場合は、 - :cfunc:`PyRun_SimpleFile` の結果を返します。 *filename* が + :c:func:`PyRun_InteractiveLoop` の値を返します。それ以外の場合は、 + :c:func:`PyRun_SimpleFile` の結果を返します。 *filename* が *NULL* ならば、この関数はファイル名として ``"???"`` を使います。 .. cfunction:: int PyRun_SimpleString(const char *command) - 下記の :cfunc:`PyRun_SimpleStringFlags` の *PyCompilerFlags\** を + 下記の :c:func:`PyRun_SimpleStringFlags` の *PyCompilerFlags\** を *NULL* にして単純化したインタフェースです。 @@ -74,32 +74,32 @@ .. cfunction:: int PyRun_SimpleFile(FILE *fp, const char *filename) - 下記の :cfunc:`PyRun_SimpleStringFileExFlags` の *closeit* を ``0`` に、 *flags* を + 下記の :c:func:`PyRun_SimpleStringFileExFlags` の *closeit* を ``0`` に、 *flags* を *NULL* にして単純化したインタフェースです。 .. cfunction:: int PyRun_SimpleFileFlags(FILE *fp, const char *filename, PyCompilerFlags *flags) - 下記の :cfunc:`PyRun_SimpleStringFileExFlags` の *closeit* を ``0`` + 下記の :c:func:`PyRun_SimpleStringFileExFlags` の *closeit* を ``0`` にして単純化したインタフェースです。 .. cfunction:: int PyRun_SimpleFileEx(FILE *fp, const char *filename, int closeit) - 下記の :cfunc:`PyRun_SimpleStringFileExFlags` の *flags* を *NULL* にし て単純化したインタフェースです。 + 下記の :c:func:`PyRun_SimpleStringFileExFlags` の *flags* を *NULL* にし て単純化したインタフェースです。 .. cfunction:: int PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags) - Similar to :cfunc:`PyRun_SimpleStringFlags`, but the Python source - :cfunc:`PyRun_SimpleString` と似ていますが、Pythonソースコードをメモリ内 の文字列ではなく *fp* から読み込みます。 + Similar to :c:func:`PyRun_SimpleStringFlags`, but the Python source + :c:func:`PyRun_SimpleString` と似ていますが、Pythonソースコードをメモリ 内の文字列ではなく *fp* から読み込みます。 *filename* はそのファイルの名前でなければなりません。 *closeit* が真なら ば、PyRun_SimpleFileExFlags は処理を戻す前に ファイルを閉じます。 .. cfunction:: int PyRun_InteractiveOne(FILE *fp, const char *filename) - 下記の :cfunc:`PyRun_InteractiveOneFlags` の *flags* を *NULL* にして単 純化したインタフェースです。 + 下記の :c:func:`PyRun_InteractiveOneFlags` の *flags* を *NULL* にして単 純化したインタフェースです。 .. cfunction:: int PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags) @@ -115,7 +115,7 @@ .. cfunction:: int PyRun_InteractiveLoop(FILE *fp, const char *filename) - 下記の :cfunc:`PyRun_InteractiveLoopFlags` の *flags* を ``0`` にして単 純化したインタフェースです。 + 下記の :c:func:`PyRun_InteractiveLoopFlags` の *flags* を ``0`` にして単 純化したインタフェースです。 .. cfunction:: int PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags) @@ -127,13 +127,13 @@ .. cfunction:: struct _node* PyParser_SimpleParseString(const char *str, int start) - 下記の :cfunc:`PyRun_SimpleParseStringFlagsFilename` の *filename* を *NULL* + 下記の :c:func:`PyRun_SimpleParseStringFlagsFilename` の *filename* を *NULL* に、 *flags* を ``0`` にして単純化したインタフェースです。 .. cfunction:: struct _node* PyParser_SimpleParseStringFlags( const char *str, int start, int flags) - 下記の :cfunc:`PyRun_SimpleParseStringFlagsFilename` の *filename* を *NULL* + 下記の :c:func:`PyRun_SimpleParseStringFlagsFilename` の *filename* を *NULL* にして単純化したインタフェースです。 @@ -145,18 +145,18 @@ .. cfunction:: struct _node* PyParser_SimpleParseFile(FILE *fp, const char *filename, int start) - 下記の :cfunc:`PyRun_SimpleParseFileFlags` の *flags* を ``0`` にして単 純化したインタフェースです。 + 下記の :c:func:`PyRun_SimpleParseFileFlags` の *flags* を ``0`` にして単 純化したインタフェースです。 .. cfunction:: struct _node* PyParser_SimpleParseFileFlags(FILE *fp, const char *filename, int start, int flags) - :cfunc:`PyParser_SimpleParseStringFlagsFilename` に似ていますが、 + :c:func:`PyParser_SimpleParseStringFlagsFilename` に似ていますが、 Pythonソースコードをメモリ内の文字列ではなく *fp* から読み込みます。 *filename* はそのファイルの名前でなけれななりません。 .. cfunction:: PyObject* PyRun_String(const char *str, int start, PyObject *globals, PyObject *locals) - 下記の :cfunc:`PyRun_StringFlags` の *flags* を *NULL* にして単純化した インタフェースです。 + 下記の :c:func:`PyRun_StringFlags` の *flags* を *NULL* にして単純化した インタフェースです。 .. cfunction:: PyObject* PyRun_StringFlags(const char *str, int start, PyObject *globals, PyObject *locals, PyCompilerFlags *flags) @@ -169,30 +169,30 @@ .. cfunction:: PyObject* PyRun_File(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals) - 下記の :cfunc:`PyRun_FileExFlags` の *closeit* を ``0`` にし、 *flags* + 下記の :c:func:`PyRun_FileExFlags` の *closeit* を ``0`` にし、 *flags* を *NULL* にして単純化したインタフェースです。 .. cfunction:: PyObject* PyRun_FileEx(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, int closeit) - 下記の :cfunc:`PyRun_FileExFlags` の *flags* を *NULL* にして単純化した インタフェースです。 + 下記の :c:func:`PyRun_FileExFlags` の *flags* を *NULL* にして単純化した インタフェースです。 .. cfunction:: PyObject* PyRun_FileFlags(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, PyCompilerFlags *flags) - 下記の :cfunc:`PyRun_FileExFlags` の *closeit* を ``0`` にして単純化した インタフェースです。 + 下記の :c:func:`PyRun_FileExFlags` の *closeit* を ``0`` にして単純化し たインタフェースです。 .. cfunction:: PyObject* PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, int closeit, PyCompilerFlags *flags) - :cfunc:`PyRun_String` と似ていますが、Pythonソースコードをメモリ内の文字 列ではなく *fp* から読み込みます。 *closeit* - を真にすると、 :cfunc:`PyRun_FileExFlags` から処理を戻す前にファイルを閉 じます。 + :c:func:`PyRun_String` と似ていますが、Pythonソースコードをメモリ内の文 字列ではなく *fp* から読み込みます。 *closeit* + を真にすると、 :c:func:`PyRun_FileExFlags` から処理を戻す前にファイルを 閉じます。 *filename* はそのファイルの名前でなければなりません。 .. cfunction:: PyObject* Py_CompileString(const char *str, const char *filename, int start) - 下記の :cfunc:`Py_CompileStringFlags` の *flags* を *NULL* にして単純化 したインタフェースです。 + 下記の :c:func:`Py_CompileStringFlags` の *flags* を *NULL* にして単純化 したインタフェースです。 .. cfunction:: PyObject* Py_CompileStringFlags(const char *str, const char *filename, int start, PyCompilerFlags *flags) @@ -207,7 +207,7 @@ .. cfunction:: PyObject* PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals) - :cfunc:`PyEval_EvalCodeEx` に対するシンプルなインタフェースで、 + :c:func:`PyEval_EvalCodeEx` に対するシンプルなインタフェースで、 コードオブジェクトと、グローバル・ローカル変数辞書だけを受け取ります。 他の引数には *NULL* が渡されます。 @@ -247,14 +247,14 @@ .. index:: single: Py_CompileString() - 単独の式に対するPython文法の開始記号で、 :cfunc:`Py_CompileString` と一 緒に使います。 + 単独の式に対するPython文法の開始記号で、 :c:func:`Py_CompileString` と一 緒に使います。 .. cvar:: int Py_file_input .. index:: single: Py_CompileString() - ファイルあるいは他のソースから読み込まれた文の並びに対するPython文法の開 始記号で、 :cfunc:`Py_CompileString` と + ファイルあるいは他のソースから読み込まれた文の並びに対するPython文法の開 始記号で、 :c:func:`Py_CompileString` と 一緒に使います。これは任意の長さのPythonソースコードをコンパイルするとき に使う記号です。 @@ -262,7 +262,7 @@ .. index:: single: Py_CompileString() - 単一の文に対するPython文法の開始記号で、 :cfunc:`Py_CompileString` と一 緒に使います。 + 単一の文に対するPython文法の開始記号で、 :c:func:`Py_CompileString` と一 緒に使います。 これは対話式のインタプリタループのための記号です。 ======================================= --- /c-api/weakref.rst Mon Dec 6 06:42:01 2010 +++ /c-api/weakref.rst Wed Mar 30 18:55:11 2011 @@ -64,11 +64,11 @@ この関数は参照先オブジェクトの **借り物の参照** を返します。 そのため、そのオブジェクトを利用している間そのオブジェクトが破棄され ない - ことが判っている場合を除き、常に :cfunc:`Py_INCREF` を呼び出すべきで す。 + ことが判っている場合を除き、常に :c:func:`Py_INCREF` を呼び出すべきで す。 .. cfunction:: PyObject* PyWeakref_GET_OBJECT(PyObject *ref) - :cfunc:`PyWeakref_GetObject` に似ていますが、マクロで実装されていて、エ ラーチェックを行いません。 + :c:func:`PyWeakref_GetObject` に似ていますが、マクロで実装されていて、エ ラーチェックを行いません。 .. versionadded:: 2.2
