memory.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2018, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-06-30 05:56+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Osamu NAKAMURA, 2017\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../c-api/memory.rst:8
msgid "Memory Management"
msgstr "メモリ管理"

#: ../../c-api/memory.rst:17
msgid "Overview"
msgstr "概要"

#: ../../c-api/memory.rst:19
msgid ""
"Memory management in Python involves a private heap containing all Python "
"objects and data structures. The management of this private heap is ensured "
"internally by the *Python memory manager*.  The Python memory manager has "
"different components which deal with various dynamic storage management "
"aspects, like sharing, segmentation, preallocation or caching."
msgstr ""
"Python におけるメモリ管理には、全ての Python オブジェクトとデータ構造が入ったプライベートヒープ (private heap) "
"が必須です。プライベートヒープの管理は、内部的には *Python メモリマネージャ (Python memory manager)* "
"が確実に行います。Python メモリマネージャには、共有 (sharing)、セグメント分割 (segmentation)、事前割り当て "
"(preallocation)、キャッシュ化 (caching) といった、様々な動的記憶管理の側面を扱うために、個別のコンポーネントがあります。"

#: ../../c-api/memory.rst:25
msgid ""
"At the lowest level, a raw memory allocator ensures that there is enough "
"room in the private heap for storing all Python-related data by interacting "
"with the memory manager of the operating system. On top of the raw memory "
"allocator, several object-specific allocators operate on the same heap and "
"implement distinct memory management policies adapted to the peculiarities "
"of every object type. For example, integer objects are managed differently "
"within the heap than strings, tuples or dictionaries because integers imply "
"different storage requirements and speed/space tradeoffs. The Python memory "
"manager thus delegates some of the work to the object-specific allocators, "
"but ensures that the latter operate within the bounds of the private heap."
msgstr ""
"最低水準層では、素のメモリ操作関数 (raw memory allocator) "
"がオペレーティングシステムのメモリ管理機構とやりとりして、プライベートヒープ内にPython "
"関連の全てのデータを記憶するのに十分な空きがあるかどうか確認します。素のメモリ操作関数の上には、いくつかのオブジェクト固有のメモリ操作関数があります。これらは同じヒープを操作し、各オブジェクト型固有の事情に合ったメモリ管理ポリシを実装しています。例えば、整数オブジェクトは文字列やタプル、辞書とは違ったやり方でヒープ内で管理されます。というのも、整数には値を記憶する上で特別な要件があり、速度/容量のトレードオフが存在するからです。このように、Python"
" "
"メモリマネジャは作業のいくつかをオブジェクト固有のメモリ操作関数に委譲しますが、これらの関数がプライベートヒープからはみ出してメモリ管理を行わないようにしています。"

#: ../../c-api/memory.rst:36
msgid ""
"It is important to understand that the management of the Python heap is "
"performed by the interpreter itself and that the user has no control over "
"it, even if they regularly manipulate object pointers to memory blocks "
"inside that heap.  The allocation of heap space for Python objects and other"
" internal buffers is performed on demand by the Python memory manager "
"through the Python/C API functions listed in this document."
msgstr ""

#: ../../c-api/memory.rst:49
msgid ""
"To avoid memory corruption, extension writers should never try to operate on"
" Python objects with the functions exported by the C library: "
":c:func:`malloc`, :c:func:`calloc`, :c:func:`realloc` and :c:func:`free`.  "
"This will result in  mixed calls between the C allocator and the Python "
"memory manager with fatal consequences, because they implement different "
"algorithms and operate on different heaps.  However, one may safely allocate"
" and release memory blocks with the C library allocator for individual "
"purposes, as shown in the following example::"
msgstr ""
"メモリ管理の崩壊を避けるため、拡張モジュールの作者は決して Python  オブジェクトを C ライブラリが公開している関数: "
":c:func:`malloc` 、 :c:func:`calloc` 、 :c:func:`realloc` および :c:func:`free` "
"で操作しようとしてはなりません。こうした関数を使うと、C のメモリ操作関数と Python メモリマネージャとの間で関数呼び出しが交錯します。 C "
"のメモリ操作関数とPython "
"メモリマネージャは異なるアルゴリズムで実装されていて、異なるヒープを操作するため、呼び出しの交錯は致命的な結果を招きます。とはいえ、個別の目的のためなら、"
" C ライブラリのメモリ操作関数を使って安全にメモリを確保したり解放したりできます。例えば、以下がそのような例です::"

#: ../../c-api/memory.rst:68
msgid ""
"In this example, the memory request for the I/O buffer is handled by the C "
"library allocator. The Python memory manager is involved only in the "
"allocation of the string object returned as a result."
msgstr ""
"この例では、I/O バッファに対するメモリ要求は C ライブラリのメモリ操作関数を使っています。Python "
"メモリマネージャーは戻り値として返される文字列オブジェクトを確保する時にだけ必要です。"

#: ../../c-api/memory.rst:72
msgid ""
"In most situations, however, it is recommended to allocate memory from the "
"Python heap specifically because the latter is under control of the Python "
"memory manager. For example, this is required when the interpreter is "
"extended with new object types written in C. Another reason for using the "
"Python heap is the desire to *inform* the Python memory manager about the "
"memory needs of the extension module. Even when the requested memory is used"
" exclusively for internal, highly-specific purposes, delegating all memory "
"requests to the Python memory manager causes the interpreter to have a more "
"accurate image of its memory footprint as a whole. Consequently, under "
"certain circumstances, the Python memory manager may or may not trigger "
"appropriate actions, like garbage collection, memory compaction or other "
"preventive procedures. Note that by using the C library allocator as shown "
"in the previous example, the allocated memory for the I/O buffer escapes "
"completely the Python memory manager."
msgstr ""
"とはいえ、ほとんどの状況では、メモリの操作は Python ヒープに固定して行うよう勧めます。なぜなら、Python ヒープは Python "
"メモリマネジャの管理下にあるからです。例えば、インタプリタを C "
"で書かれた新たなオブジェクト型で拡張する際には、ヒープでのメモリ管理が必要です。Python "
"ヒープを使った方がよいもう一つの理由として、拡張モジュールが必要としているメモリについて Python メモリマネージャに *情報を提供* "
"してほしいということがあります。たとえ必要なメモリが内部的かつ非常に特化した用途に対して排他的に用いられるものだとしても、全てのメモリ操作要求を "
"Python メモリマネージャに委譲すれば、インタプリタはより正確なメモリフットプリントの全体像を把握できます。その結果、特定の状況では、Python "
"メモリマネージャがガベージコレクションやメモリのコンパクト化、その他何らかの予防措置といった、適切な動作をトリガできることがあります。上の例で示したように"
" C ライブラリのメモリ操作関数を使うと、I/O バッファ用に確保したメモリは Python "
"メモリマネージャの管理から完全に外れることに注意してください。"

#: ../../c-api/memory.rst:88
msgid ""
"The :envvar:`PYTHONMALLOC` environment variable can be used to configure the"
" memory allocators used by Python."
msgstr "環境変数 :envvar:`PYTHONMALLOC` を使用して Python が利用するメモリアロケータを制御することができます。"

#: ../../c-api/memory.rst:91
msgid ""
"The :envvar:`PYTHONMALLOCSTATS` environment variable can be used to print "
"statistics of the :ref:`pymalloc memory allocator <pymalloc>` every time a "
"new pymalloc object arena is created, and on shutdown."
msgstr ""
"環境変数 :envvar:`PYTHONMALLOCSTATS` を使用して、新たなオブジェクトアリーナが生成される時と、シャットダウン時に "
":ref:`pymalloc メモリアロケータ <pymalloc>` の統計情報を表示できます。"

#: ../../c-api/memory.rst:97
msgid "Raw Memory Interface"
msgstr "生メモリインタフェース"

#: ../../c-api/memory.rst:99
msgid ""
"The following function sets are wrappers to the system allocator. These "
"functions are thread-safe, the :term:`GIL <global interpreter lock>` does "
"not need to be held."
msgstr ""
"以下の関数群はシステムのアロケータをラップします。\n"
"これらの関数はスレッドセーフで、 :term:`GIL <global interpreter lock>` を保持していなくても呼び出すことができます。"

#: ../../c-api/memory.rst:103
msgid ""
"The :ref:`default raw memory allocator <default-memory-allocators>` uses the"
" following functions: :c:func:`malloc`, :c:func:`calloc`, :c:func:`realloc` "
"and :c:func:`free`; call ``malloc(1)`` (or ``calloc(1, 1)``) when requesting"
" zero bytes."
msgstr ""

#: ../../c-api/memory.rst:112 ../../c-api/memory.rst:183
#: ../../c-api/memory.rst:285
msgid ""
"Allocates *n* bytes and returns a pointer of type :c:type:`void\\*` to the "
"allocated memory, or *NULL* if the request fails."
msgstr ""
"*n* バイトを割り当て、そのメモリを指す :c:type:`void\\*` 型のポインタを返します。要求が失敗した場合 *NULL* を返します。"

#: ../../c-api/memory.rst:115
msgid ""
"Requesting zero bytes returns a distinct non-*NULL* pointer if possible, as "
"if ``PyMem_RawMalloc(1)`` had been called instead. The memory will not have "
"been initialized in any way."
msgstr ""
"0バイトを要求すると、 ``PyMem_RawMalloc(1)`` が呼ばれたときと同じように、可能なら *NULL* "
"でないユニークなポインタを返します。確保されたメモリーにはいかなる初期化も行われません。"

#: ../../c-api/memory.rst:122 ../../c-api/memory.rst:193
#: ../../c-api/memory.rst:295
msgid ""
"Allocates *nelem* elements each whose size in bytes is *elsize* and returns "
"a pointer of type :c:type:`void\\*` to the allocated memory, or *NULL* if "
"the request fails. The memory is initialized to zeros."
msgstr ""
"各要素が *elsize* バイトの要素 *nelem* 個分のメモリーを確保し、そのメモリーを指す :c:type:`void\\*` "
"型のポインタを返します。アロケートに失敗した場合は *NULL* を返します。確保されたメモリー領域はゼロで初期化されます。"

#: ../../c-api/memory.rst:126
msgid ""
"Requesting zero elements or elements of size zero bytes returns a distinct "
"non-*NULL* pointer if possible, as if ``PyMem_RawCalloc(1, 1)`` had been "
"called instead."
msgstr ""
"要素数か要素のサイズが0バイトの要求に対しては、可能なら ``PyMem_RawCalloc(1, 1)`` が呼ばれたのと同じように、ユニークな "
"*NULL* でないポインタを返します。"

#: ../../c-api/memory.rst:135 ../../c-api/memory.rst:206
#: ../../c-api/memory.rst:308
msgid ""
"Resizes the memory block pointed to by *p* to *n* bytes. The contents will "
"be unchanged to the minimum of the old and the new sizes."
msgstr "*p* が指すメモリブロックを *n* バイトにリサイズします。古いサイズと新しいサイズの小さい方までの内容は変更されません。"

#: ../../c-api/memory.rst:138
msgid ""
"If *p* is *NULL*, the call is equivalent to ``PyMem_RawMalloc(n)``; else if "
"*n* is equal to zero, the memory block is resized but is not freed, and the "
"returned pointer is non-*NULL*."
msgstr ""
"*p* が *NULL* の場合呼び出しは ``PyMem_RawMalloc(n)`` と等価です。そうでなく、 *n* "
"がゼロに等しい場合、メモリブロックはリサイズされますが解放されません。返されたポインタは非 *NULL* です。"

#: ../../c-api/memory.rst:142
msgid ""
"Unless *p* is *NULL*, it must have been returned by a previous call to "
":c:func:`PyMem_RawMalloc`, :c:func:`PyMem_RawRealloc` or "
":c:func:`PyMem_RawCalloc`."
msgstr ""
"*p* が *NULL* でない限り、*p* はそれより前の :c:func:`PyMem_RawMalloc`, "
":c:func:`PyMem_RawRealloc`, :c:func:`PyMem_RawCalloc` の呼び出しにより返されなければなりません。"

#: ../../c-api/memory.rst:146
msgid ""
"If the request fails, :c:func:`PyMem_RawRealloc` returns *NULL* and *p* "
"remains a valid pointer to the previous memory area."
msgstr ""
"要求が失敗した場合 :c:func:`PyMem_RawRealloc` は *NULL* を返し、 *p* "
"は前のメモリエリアをさす有効なポインタのままです。"

#: ../../c-api/memory.rst:152
msgid ""
"Frees the memory block pointed to by *p*, which must have been returned by a"
" previous call to :c:func:`PyMem_RawMalloc`, :c:func:`PyMem_RawRealloc` or "
":c:func:`PyMem_RawCalloc`.  Otherwise, or if ``PyMem_RawFree(p)`` has been "
"called before, undefined behavior occurs."
msgstr ""

#: ../../c-api/memory.rst:157 ../../c-api/memory.rst:227
#: ../../c-api/memory.rst:329
msgid "If *p* is *NULL*, no operation is performed."
msgstr "*p* が *NULL* の場合何もしません。"

#: ../../c-api/memory.rst:163
msgid "Memory Interface"
msgstr "メモリインタフェース"

#: ../../c-api/memory.rst:165 ../../c-api/memory.rst:271
msgid ""
"The following function sets, modeled after the ANSI C standard, but "
"specifying behavior when requesting zero bytes, are available for allocating"
" and releasing memory from the Python heap."
msgstr ""
"以下の関数群が利用して Python ヒープに対してメモリを確保したり解放したり出来ます。これらの関数は ANSI C "
"標準に従ってモデル化されていますが、0 バイトを要求した際の動作についても定義しています:"

#: ../../c-api/memory.rst:169
msgid ""
"The :ref:`default memory allocator <default-memory-allocators>` uses the "
":ref:`pymalloc memory allocator <pymalloc>`."
msgstr ""

#: ../../c-api/memory.rst:174 ../../c-api/memory.rst:280
msgid ""
"The :term:`GIL <global interpreter lock>` must be held when using these "
"functions."
msgstr "これらの関数を呼ぶときには、 :term:`GIL <global interpreter lock>` を保持しておく必要があります。"

#: ../../c-api/memory.rst:179
msgid ""
"The default allocator is now pymalloc instead of system :c:func:`malloc`."
msgstr "デフォルトのアロケータがシステムの :c:func:`malloc` から pymalloc になりました。"

#: ../../c-api/memory.rst:186
msgid ""
"Requesting zero bytes returns a distinct non-*NULL* pointer if possible, as "
"if ``PyMem_Malloc(1)`` had been called instead. The memory will not have "
"been initialized in any way."
msgstr ""
"0バイトを要求すると、 ``PyMem_Malloc(1)`` が呼ばれたときと同じように、可能なら *NULL* でないユニークなポインタを返します。\n"
"確保されたメモリーにはいかなる初期化も行われません。"

#: ../../c-api/memory.rst:197
msgid ""
"Requesting zero elements or elements of size zero bytes returns a distinct "
"non-*NULL* pointer if possible, as if ``PyMem_Calloc(1, 1)`` had been called"
" instead."
msgstr ""
"要素数か要素のサイズが0バイトの要求に対しては、可能なら ``PyMem_Calloc(1, 1)`` が呼ばれたのと同じように、ユニークな "
"*NULL* でないポインタを返します。"

#: ../../c-api/memory.rst:209
msgid ""
"If *p* is *NULL*, the call is equivalent to ``PyMem_Malloc(n)``; else if *n*"
" is equal to zero, the memory block is resized but is not freed, and the "
"returned pointer is non-*NULL*."
msgstr ""
"*p* が *NULL* の場合呼び出しは ``PyMem_Malloc(n)`` と等価です。そうでなく、 *n* "
"がゼロに等しい場合、メモリブロックはリサイズされますが解放されません。返されたポインタは非 *NULL* です。"

#: ../../c-api/memory.rst:213
msgid ""
"Unless *p* is *NULL*, it must have been returned by a previous call to "
":c:func:`PyMem_Malloc`, :c:func:`PyMem_Realloc` or :c:func:`PyMem_Calloc`."
msgstr ""
"*p* が *NULL* でない限り、*p* はそれより前の :c:func:`PyMem_Malloc`, "
":c:func:`PyMem_Realloc` または :c:func:`PyMem_Calloc` の呼び出しにより返されなければなりません。"

#: ../../c-api/memory.rst:216
msgid ""
"If the request fails, :c:func:`PyMem_Realloc` returns *NULL* and *p* remains"
" a valid pointer to the previous memory area."
msgstr ""
"要求が失敗した場合 :c:func:`PyMem_Realloc` は *NULL* を返し、 *p* "
"は前のメモリエリアをさす有効なポインタのままです。"

#: ../../c-api/memory.rst:222
msgid ""
"Frees the memory block pointed to by *p*, which must have been returned by a"
" previous call to :c:func:`PyMem_Malloc`, :c:func:`PyMem_Realloc` or "
":c:func:`PyMem_Calloc`.  Otherwise, or if ``PyMem_Free(p)`` has been called "
"before, undefined behavior occurs."
msgstr ""
"*p* が指すメモリブロックを解放します。 *p* は以前呼び出した :c:func:`PyMem_Malloc`、 "
":c:func:`PyMem_Realloc`、または :c:func:`PyMem_Calloc` の返した値でなければなりません。それ以外の場合や "
"``PyMem_Free(p)`` を呼び出した後だった場合、未定義の動作になります。"

#: ../../c-api/memory.rst:229
msgid ""
"The following type-oriented macros are provided for convenience.  Note  that"
" *TYPE* refers to any C type."
msgstr "以下に挙げる型対象のマクロは利便性のために提供されているものです。*TYPE* は任意の C の型を表します。"

#: ../../c-api/memory.rst:235
msgid ""
"Same as :c:func:`PyMem_Malloc`, but allocates ``(n * sizeof(TYPE))`` bytes "
"of memory.  Returns a pointer cast to :c:type:`TYPE\\*`.  The memory will "
"not have been initialized in any way."
msgstr ""
":c:func:`PyMem_Malloc` と同じですが、 ``(n * sizeof(TYPE))`` バイトのメモリを確保します。 "
":c:type:`TYPE\\*` に型キャストされたポインタを返します。メモリには何の初期化も行われていません。"

#: ../../c-api/memory.rst:242
msgid ""
"Same as :c:func:`PyMem_Realloc`, but the memory block is resized to ``(n * "
"sizeof(TYPE))`` bytes.  Returns a pointer cast to :c:type:`TYPE\\*`. On "
"return, *p* will be a pointer to the new memory area, or *NULL* in the event"
" of failure."
msgstr ""
":c:func:`PyMem_Realloc` と同じですが、 ``(n * sizeof(TYPE))`` バイトにサイズ変更されたメモリを確保します。\n"
":c:type:`TYPE\\*` に型キャストされたポインタを返します。\n"
"関数が終わったとき、 *p* は新しいメモリ領域のポインタか、失敗した場合は *NULL* になります。"

#: ../../c-api/memory.rst:247
msgid ""
"This is a C preprocessor macro; *p* is always reassigned.  Save the original"
" value of *p* to avoid losing memory when handling errors."
msgstr ""
"これは C プリプロセッサマクロです。*p* は常に再代入されます。エラー処理時にメモリを失うのを避けるには *p* の元の値を保存してください。"

#: ../../c-api/memory.rst:253
msgid "Same as :c:func:`PyMem_Free`."
msgstr ":c:func:`PyMem_Free` と同じです。"

#: ../../c-api/memory.rst:255
msgid ""
"In addition, the following macro sets are provided for calling the Python "
"memory allocator directly, without involving the C API functions listed "
"above. However, note that their use does not preserve binary compatibility "
"across Python versions and is therefore deprecated in extension modules."
msgstr ""
"上記に加えて、C API 関数を介することなく Python "
"メモリ操作関数を直接呼び出すための以下のマクロセットが提供されています。ただし、これらのマクロは Python "
"バージョン間でのバイナリ互換性を保てず、それゆえに拡張モジュールでは撤廃されているので注意してください。"

#: ../../c-api/memory.rst:260
msgid "``PyMem_MALLOC(size)``"
msgstr "``PyMem_MALLOC(size)``"

#: ../../c-api/memory.rst:261
msgid "``PyMem_NEW(type, size)``"
msgstr "``PyMem_NEW(type, size)``"

#: ../../c-api/memory.rst:262
msgid "``PyMem_REALLOC(ptr, size)``"
msgstr "``PyMem_REALLOC(ptr, size)``"

#: ../../c-api/memory.rst:263
msgid "``PyMem_RESIZE(ptr, type, size)``"
msgstr "``PyMem_RESIZE(ptr, type, size)``"

#: ../../c-api/memory.rst:264
msgid "``PyMem_FREE(ptr)``"
msgstr "``PyMem_FREE(ptr)``"

#: ../../c-api/memory.rst:265
msgid "``PyMem_DEL(ptr)``"
msgstr "``PyMem_DEL(ptr)``"

#: ../../c-api/memory.rst:269
msgid "Object allocators"
msgstr ""

#: ../../c-api/memory.rst:275
msgid ""
"The :ref:`default object allocator <default-memory-allocators>` uses the "
":ref:`pymalloc memory allocator <pymalloc>`."
msgstr ""

#: ../../c-api/memory.rst:288
msgid ""
"Requesting zero bytes returns a distinct non-*NULL* pointer if possible, as "
"if ``PyObject_Malloc(1)`` had been called instead. The memory will not have "
"been initialized in any way."
msgstr ""

#: ../../c-api/memory.rst:299
msgid ""
"Requesting zero elements or elements of size zero bytes returns a distinct "
"non-*NULL* pointer if possible, as if ``PyObject_Calloc(1, 1)`` had been "
"called instead."
msgstr ""

#: ../../c-api/memory.rst:311
msgid ""
"If *p* is *NULL*, the call is equivalent to ``PyObject_Malloc(n)``; else if "
"*n* is equal to zero, the memory block is resized but is not freed, and the "
"returned pointer is non-*NULL*."
msgstr ""

#: ../../c-api/memory.rst:315
msgid ""
"Unless *p* is *NULL*, it must have been returned by a previous call to "
":c:func:`PyObject_Malloc`, :c:func:`PyObject_Realloc` or "
":c:func:`PyObject_Calloc`."
msgstr ""

#: ../../c-api/memory.rst:318
msgid ""
"If the request fails, :c:func:`PyObject_Realloc` returns *NULL* and *p* "
"remains a valid pointer to the previous memory area."
msgstr ""

#: ../../c-api/memory.rst:324
msgid ""
"Frees the memory block pointed to by *p*, which must have been returned by a"
" previous call to :c:func:`PyObject_Malloc`, :c:func:`PyObject_Realloc` or "
":c:func:`PyObject_Calloc`.  Otherwise, or if ``PyObject_Free(p)`` has been "
"called before, undefined behavior occurs."
msgstr ""

#: ../../c-api/memory.rst:335
msgid "Default Memory Allocators"
msgstr ""

#: ../../c-api/memory.rst:337
msgid "Default memory allocators:"
msgstr ""

#: ../../c-api/memory.rst:340
msgid "Configuration"
msgstr "Configuration"

#: ../../c-api/memory.rst:340
msgid "Name"
msgstr "名前"

#: ../../c-api/memory.rst:340
msgid "PyMem_RawMalloc"
msgstr ""

#: ../../c-api/memory.rst:340
msgid "PyMem_Malloc"
msgstr ""

#: ../../c-api/memory.rst:340
msgid "PyObject_Malloc"
msgstr ""

#: ../../c-api/memory.rst:342
msgid "Release build"
msgstr ""

#: ../../c-api/memory.rst:342
msgid "``\"pymalloc\"``"
msgstr ""

#: ../../c-api/memory.rst:342 ../../c-api/memory.rst:344
#: ../../c-api/memory.rst:344 ../../c-api/memory.rst:344
msgid "``malloc``"
msgstr ""

#: ../../c-api/memory.rst:342 ../../c-api/memory.rst:342
msgid "``pymalloc``"
msgstr ""

#: ../../c-api/memory.rst:343
msgid "Debug build"
msgstr ""

#: ../../c-api/memory.rst:343
msgid "``\"pymalloc_debug\"``"
msgstr ""

#: ../../c-api/memory.rst:343 ../../c-api/memory.rst:345
#: ../../c-api/memory.rst:345 ../../c-api/memory.rst:345
msgid "``malloc`` + debug"
msgstr ""

#: ../../c-api/memory.rst:343 ../../c-api/memory.rst:343
msgid "``pymalloc`` + debug"
msgstr ""

#: ../../c-api/memory.rst:344 ../../c-api/memory.rst:345
msgid "Release build, without pymalloc"
msgstr ""

#: ../../c-api/memory.rst:344
msgid "``\"malloc\"``"
msgstr ""

#: ../../c-api/memory.rst:345
msgid "``\"malloc_debug\"``"
msgstr ""

#: ../../c-api/memory.rst:348
msgid "Legend:"
msgstr ""

#: ../../c-api/memory.rst:350
msgid "Name: value for :envvar:`PYTHONMALLOC` environment variable"
msgstr ""

#: ../../c-api/memory.rst:351
msgid ""
"``malloc``: system allocators from the standard C library, C functions: "
":c:func:`malloc`, :c:func:`calloc`, :c:func:`realloc` and :c:func:`free`"
msgstr ""

#: ../../c-api/memory.rst:353
msgid "``pymalloc``: :ref:`pymalloc memory allocator <pymalloc>`"
msgstr ""

#: ../../c-api/memory.rst:354
msgid "\"+ debug\": with debug hooks installed by :c:func:`PyMem_SetupDebugHooks`"
msgstr ""

#: ../../c-api/memory.rst:358
msgid "Customize Memory Allocators"
msgstr "メモリアロケータをカスタマイズする"

#: ../../c-api/memory.rst:364
msgid ""
"Structure used to describe a memory block allocator. The structure has four "
"fields:"
msgstr "メモリブロックアロケータを記述するための構造体です。4つのフィールドを持ちます:"

#: ../../c-api/memory.rst:368 ../../c-api/memory.rst:506
msgid "Field"
msgstr "フィールド"

#: ../../c-api/memory.rst:368 ../../c-api/memory.rst:506
msgid "Meaning"
msgstr "意味"

#: ../../c-api/memory.rst:370 ../../c-api/memory.rst:508
msgid "``void *ctx``"
msgstr "``void *ctx``"

#: ../../c-api/memory.rst:370 ../../c-api/memory.rst:508
msgid "user context passed as first argument"
msgstr "第一引数として渡されるユーザコンテクスト"

#: ../../c-api/memory.rst:372
msgid "``void* malloc(void *ctx, size_t size)``"
msgstr "``void* malloc(void *ctx, size_t size)``"

#: ../../c-api/memory.rst:372
msgid "allocate a memory block"
msgstr "メモリブロックを割り当てます"

#: ../../c-api/memory.rst:374
msgid "``void* calloc(void *ctx, size_t nelem, size_t elsize)``"
msgstr "``void* calloc(void *ctx, size_t nelem, size_t elsize)``"

#: ../../c-api/memory.rst:374
msgid "allocate a memory block initialized with zeros"
msgstr "0で初期化されたメモリブロックを割り当てます"

#: ../../c-api/memory.rst:377
msgid "``void* realloc(void *ctx, void *ptr, size_t new_size)``"
msgstr "``void* realloc(void *ctx, void *ptr, size_t new_size)``"

#: ../../c-api/memory.rst:377
msgid "allocate or resize a memory block"
msgstr "メモリブロックを割り当てるかリサイズします"

#: ../../c-api/memory.rst:379
msgid "``void free(void *ctx, void *ptr)``"
msgstr "``void free(void *ctx, void *ptr)``"

#: ../../c-api/memory.rst:379
msgid "free a memory block"
msgstr "メモリブロックを解放する"

#: ../../c-api/memory.rst:382
msgid ""
"The :c:type:`PyMemAllocator` structure was renamed to "
":c:type:`PyMemAllocatorEx` and a new ``calloc`` field was added."
msgstr ""
":c:type:`PyMemAllocator` 構造体が :c:type:`PyMemAllocatorEx` にリネームされた上で "
"``calloc`` フィールドが追加されました。"

#: ../../c-api/memory.rst:389
msgid "Enum used to identify an allocator domain. Domains:"
msgstr "アロケータドメインを同定するための列挙型です。ドメインは:"

#: ../../c-api/memory.rst:393 ../../c-api/memory.rst:402
#: ../../c-api/memory.rst:411
msgid "Functions:"
msgstr "関数:"

#: ../../c-api/memory.rst:395
msgid ":c:func:`PyMem_RawMalloc`"
msgstr ":c:func:`PyMem_RawMalloc`"

#: ../../c-api/memory.rst:396
msgid ":c:func:`PyMem_RawRealloc`"
msgstr ":c:func:`PyMem_RawRealloc`"

#: ../../c-api/memory.rst:397
msgid ":c:func:`PyMem_RawCalloc`"
msgstr ":c:func:`PyMem_RawCalloc`"

#: ../../c-api/memory.rst:398
msgid ":c:func:`PyMem_RawFree`"
msgstr ":c:func:`PyMem_RawFree`"

#: ../../c-api/memory.rst:404
msgid ":c:func:`PyMem_Malloc`,"
msgstr ":c:func:`PyMem_Malloc`,"

#: ../../c-api/memory.rst:405
msgid ":c:func:`PyMem_Realloc`"
msgstr ":c:func:`PyMem_Realloc`"

#: ../../c-api/memory.rst:406
msgid ":c:func:`PyMem_Calloc`"
msgstr ":c:func:`PyMem_Calloc`"

#: ../../c-api/memory.rst:407
msgid ":c:func:`PyMem_Free`"
msgstr ":c:func:`PyMem_Free`"

#: ../../c-api/memory.rst:413
msgid ":c:func:`PyObject_Malloc`"
msgstr ":c:func:`PyObject_Malloc`"

#: ../../c-api/memory.rst:414
msgid ":c:func:`PyObject_Realloc`"
msgstr ":c:func:`PyObject_Realloc`"

#: ../../c-api/memory.rst:415
msgid ":c:func:`PyObject_Calloc`"
msgstr ":c:func:`PyObject_Calloc`"

#: ../../c-api/memory.rst:416
msgid ":c:func:`PyObject_Free`"
msgstr ":c:func:`PyObject_Free`"

#: ../../c-api/memory.rst:420
msgid "Get the memory block allocator of the specified domain."
msgstr "指定されたドメインのメモリブロックアロケータを取得します。"

#: ../../c-api/memory.rst:425
msgid "Set the memory block allocator of the specified domain."
msgstr "指定されたドメインのメモリブロックアロケータを設定します。"

#: ../../c-api/memory.rst:427
msgid ""
"The new allocator must return a distinct non-NULL pointer when requesting "
"zero bytes."
msgstr "新しいアロケータは、0バイトを要求されたときユニークな NULL でないポインタを返さなければなりません。"

#: ../../c-api/memory.rst:430
msgid ""
"For the :c:data:`PYMEM_DOMAIN_RAW` domain, the allocator must be thread-"
"safe: the :term:`GIL <global interpreter lock>` is not held when the "
"allocator is called."
msgstr ""
":c:data:`PYMEM_DOMAIN_RAW` ドメインでは、アロケータはスレッドセーフでなければなりません: アロケータが呼び出されたとき "
":term:`GIL <global interpreter lock>` は保持されていません。"

#: ../../c-api/memory.rst:434
msgid ""
"If the new allocator is not a hook (does not call the previous allocator), "
"the :c:func:`PyMem_SetupDebugHooks` function must be called to reinstall the"
" debug hooks on top on the new allocator."
msgstr ""
"新しいアロケータがフックでない (1つ前のアロケータを呼び出さない) 場合、 :c:func:`PyMem_SetupDebugHooks` "
"関数を呼び出して、新しいアロケータの上にデバッグフックを再度設置しなければなりません。"

#: ../../c-api/memory.rst:441
msgid "Setup hooks to detect bugs in the Python memory allocator functions."
msgstr "Python メモリアロケータ関数のバグを検出するためのフックを設定します。"

#: ../../c-api/memory.rst:443
msgid ""
"Newly allocated memory is filled with the byte ``0xCB``, freed memory is "
"filled with the byte ``0xDB``."
msgstr "新たに割り当てられたメモリはバイト ``0xCB`` で埋められ、解放されたメモリはバイト ``0xDB`` で埋められます。"

#: ../../c-api/memory.rst:446
msgid "Runtime checks:"
msgstr "実行時チェック:"

#: ../../c-api/memory.rst:448
msgid ""
"Detect API violations, ex: :c:func:`PyObject_Free` called on a buffer "
"allocated by :c:func:`PyMem_Malloc`"
msgstr ""
"API 違反を検出します。例: :c:func:`PyMem_Malloc` が割り当てたバッファに対して "
":c:func:`PyObject_Free` を呼びだした。"

#: ../../c-api/memory.rst:450
msgid "Detect write before the start of the buffer (buffer underflow)"
msgstr "バッファの開始前の書き込み (バッファアンダーフロー) を検出します"

#: ../../c-api/memory.rst:451
msgid "Detect write after the end of the buffer (buffer overflow)"
msgstr "バッファ終了後の書き込み (バッファオーバーフロー) を検出します"

#: ../../c-api/memory.rst:452
msgid ""
"Check that the :term:`GIL <global interpreter lock>` is held when allocator "
"functions of :c:data:`PYMEM_DOMAIN_OBJ` (ex: :c:func:`PyObject_Malloc`) and "
":c:data:`PYMEM_DOMAIN_MEM` (ex: :c:func:`PyMem_Malloc`) domains are called"
msgstr ""

#: ../../c-api/memory.rst:457
msgid ""
"On error, the debug hooks use the :mod:`tracemalloc` module to get the "
"traceback where a memory block was allocated. The traceback is only "
"displayed if :mod:`tracemalloc` is tracing Python memory allocations and the"
" memory block was traced."
msgstr ""

#: ../../c-api/memory.rst:462
msgid ""
"These hooks are :ref:`installed by default <default-memory-allocators>` if "
"Python is compiled in debug mode. The :envvar:`PYTHONMALLOC` environment "
"variable can be used to install debug hooks on a Python compiled in release "
"mode."
msgstr ""

#: ../../c-api/memory.rst:467
msgid ""
"This function now also works on Python compiled in release mode. On error, "
"the debug hooks now use :mod:`tracemalloc` to get the traceback where a "
"memory block was allocated. The debug hooks now also check if the GIL is "
"held when functions of :c:data:`PYMEM_DOMAIN_OBJ` and "
":c:data:`PYMEM_DOMAIN_MEM` domains are called."
msgstr ""

#: ../../c-api/memory.rst:478
msgid "The pymalloc allocator"
msgstr "pymalloc アロケータ"

#: ../../c-api/memory.rst:480
msgid ""
"Python has a *pymalloc* allocator optimized for small objects (smaller or "
"equal to 512 bytes) with a short lifetime. It uses memory mappings called "
"\"arenas\" with a fixed size of 256 KiB. It falls back to "
":c:func:`PyMem_RawMalloc` and :c:func:`PyMem_RawRealloc` for allocations "
"larger than 512 bytes."
msgstr ""

#: ../../c-api/memory.rst:485
msgid ""
"*pymalloc* is the :ref:`default allocator <default-memory-allocators>` of "
"the :c:data:`PYMEM_DOMAIN_MEM` (ex: :c:func:`PyMem_Malloc`) and "
":c:data:`PYMEM_DOMAIN_OBJ` (ex: :c:func:`PyObject_Malloc`) domains."
msgstr ""

#: ../../c-api/memory.rst:489
msgid "The arena allocator uses the following functions:"
msgstr "アリーナアロケータは、次の関数を使います:"

#: ../../c-api/memory.rst:491
msgid ":c:func:`VirtualAlloc` and :c:func:`VirtualFree` on Windows,"
msgstr "Windows では :c:func:`VirtualAlloc` と :c:func:`VirtualFree`、"

#: ../../c-api/memory.rst:492
msgid ":c:func:`mmap` and :c:func:`munmap` if available,"
msgstr "利用できる場合、:c:func:`mmap` と :c:func:`munmap`、"

#: ../../c-api/memory.rst:493
msgid ":c:func:`malloc` and :c:func:`free` otherwise."
msgstr "それ以外の場合は :c:func:`malloc` と :c:func:`free`。"

#: ../../c-api/memory.rst:496
msgid "Customize pymalloc Arena Allocator"
msgstr "pymalloc アリーナアロケータのカスタマイズ"

#: ../../c-api/memory.rst:502
msgid ""
"Structure used to describe an arena allocator. The structure has three "
"fields:"
msgstr "アリーナアロケータを記述するための構造体です。3つのフィールドを持ちます:"

#: ../../c-api/memory.rst:510
msgid "``void* alloc(void *ctx, size_t size)``"
msgstr "``void* alloc(void *ctx, size_t size)``"

#: ../../c-api/memory.rst:510
msgid "allocate an arena of size bytes"
msgstr "size バイトのアリーナを割り当てます"

#: ../../c-api/memory.rst:512
msgid "``void free(void *ctx, size_t size, void *ptr)``"
msgstr "``void free(void *ctx, size_t size, void *ptr)``"

#: ../../c-api/memory.rst:512
msgid "free an arena"
msgstr "アリーナを解放します"

#: ../../c-api/memory.rst:517
msgid "Get the arena allocator."
msgstr "アリーナアロケータを取得します。"

#: ../../c-api/memory.rst:521
msgid "Set the arena allocator."
msgstr "アリーナアロケータを設定します。"

#: ../../c-api/memory.rst:525
msgid "tracemalloc C API"
msgstr ""

#: ../../c-api/memory.rst:549
msgid "Examples"
msgstr "使用例"

#: ../../c-api/memory.rst:551
msgid ""
"Here is the example from section :ref:`memoryoverview`, rewritten so that "
"the I/O buffer is allocated from the Python heap by using the first function"
" set::"
msgstr ""
"最初に述べた関数セットを使って、 :ref:`memoryoverview` 節の例を Python ヒープに I/O "
"バッファをメモリ確保するように書き換えたものを以下に示します::"

#: ../../c-api/memory.rst:564
msgid "The same code using the type-oriented function set::"
msgstr "同じコードを型対象の関数セットで書いたものを以下に示します::"

#: ../../c-api/memory.rst:576
msgid ""
"Note that in the two examples above, the buffer is always manipulated via "
"functions belonging to the same set. Indeed, it is required to use the same "
"memory API family for a given memory block, so that the risk of mixing "
"different allocators is reduced to a minimum. The following code sequence "
"contains two errors, one of which is labeled as *fatal* because it mixes two"
" different allocators operating on different heaps. ::"
msgstr ""
"上の二つの例では、バッファを常に同じ関数セットに属する関数で操作していることに注意してください。実際、あるメモリブロックに対する操作は、異なるメモリ操作機構を混用する危険を減らすために、同じメモリ"
" API "
"ファミリを使って行うことが必要です。以下のコードには二つのエラーがあり、そのうちの一つには異なるヒープを操作する別のメモリ操作関数を混用しているので "
"*致命的 (Fatal)* とラベルづけをしています。 ::"

#: ../../c-api/memory.rst:591
msgid ""
"In addition to the functions aimed at handling raw memory blocks from the "
"Python heap, objects in Python are allocated and released with "
":c:func:`PyObject_New`, :c:func:`PyObject_NewVar` and "
":c:func:`PyObject_Del`."
msgstr ""
"素のメモリブロックを Python ヒープ上で操作する関数に加え、 :c:func:`PyObject_New` 、 "
":c:func:`PyObject_NewVar` 、および :c:func:`PyObject_Del` を使うと、 Python "
"におけるオブジェクトをメモリ確保したり解放したりできます。"

#: ../../c-api/memory.rst:595
msgid ""
"These will be explained in the next chapter on defining and implementing new"
" object types in C."
msgstr "これらの関数については、次章の C による新しいオブジェクト型の定義や実装に関する記述の中で説明します。"