# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-04-05 14:30+0000\n"

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

"Last-Translator: python-doc bot, 2025\n"

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

"ja/)\n"

"MIME-Version: 1.0\n"

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

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

"Language: ja\n"

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

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

msgid "Embedding Python in Another Application"

msgstr "他のアプリケーションへの Python の埋め込み"

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

msgid ""

"The previous chapters discussed how to extend Python, that is, how to extend "

"the functionality of Python by attaching a library of C functions to it. It "

"is also possible to do it the other way around: enrich your C/C++ "

"application by embedding Python in it. Embedding provides your application "

"with the ability to implement some of the functionality of your application "

"in Python rather than C or C++. This can be used for many purposes; one "

"example would be to allow users to tailor the application to their needs by "

"writing some scripts in Python. You can also use it yourself if some of the "

"functionality can be written in Python more easily."

msgstr ""

"前章では、 Python を拡張する方法、すなわち C 関数のライブラリを Python に結び"

"つけて機能を拡張する方法について述べました。同じようなことを別の方法でも実行"

"できます: それは、自分の C/C++ アプリケーションに Python を埋め込んで機能を強"

"化する、というものです。埋め込みを行うことで、アプリケーションの何らかの機能"

"を C や C++ の代わりに Python で実装できるようになります。埋め込みは多くの用"

"途で利用できます; ユーザが Python でスクリプトを書き、アプリケーションを自分"

"好みに仕立てられるようにする、というのがその一例です。プログラマが、特定の機"

"能を Python でより楽に書ける場合に自分自身のために埋め込みを行うこともできま"

"す。"

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

msgid ""

"Embedding Python is similar to extending it, but not quite. The difference "

"is that when you extend Python, the main program of the application is still "

"the Python interpreter, while if you embed Python, the main program may have "

"nothing to do with Python --- instead, some parts of the application "

"occasionally call the Python interpreter to run some Python code."

msgstr ""

"Python の埋め込みは Python の拡張と似ていますが、全く同じというわけではありま"

"せん。その違いは、Python を拡張した場合にはアプリケーションのメインプログラム"

"は依然として Python インタプリタである一方、 Python を組み込みんだ場合には、"

"メインプログラムには Python が関係しない --- その代わりに、アプリケーションの"

"ある一部分が時折 Python インタプリタを呼び出して何らかの Python コードを実行"

"させる --- かもしれない、ということです。"

#: ../../extending/embedding.rst:26

msgid ""

"So if you are embedding Python, you are providing your own main program. "

"One of the things this main program has to do is initialize the Python "

"interpreter. At the very least, you have to call the function :c:func:"

"`Py_Initialize`. There are optional calls to pass command line arguments to "

"Python. Then later you can call the interpreter from any part of the "

"application."

msgstr ""

"従って、 Python の埋め込みを行う場合、自作のメインプログラムを提供しなければ"

"なりません。メインプログラムがやらなければならないことの一つに、 Python イン"

"タプリタの初期化があります。とにかく少なくとも関数 :c:func:`Py_Initialize` を"

"呼び出さねばなりません。オプションとして、Python 側にコマンドライン引数を渡す"

"ために関数呼び出しを行います。その後、アプリケーションのどこでもインタプリタ"

"を呼び出せるようになります。"

#: ../../extending/embedding.rst:32

msgid ""

"There are several different ways to call the interpreter: you can pass a "

"string containing Python statements to :c:func:`PyRun_SimpleString`, or you "

"can pass a stdio file pointer and a file name (for identification in error "

"messages only) to :c:func:`PyRun_SimpleFile`. You can also call the lower-"

"level operations described in the previous chapters to construct and use "

"Python objects."

msgstr ""

"インタプリタを呼び出すには、異なるいくつかの方法があります: Python 文が入った"

"文字列を :c:func:`PyRun_SimpleString` に渡す、 stdio ファイルポインタとファイ"

"ル名 (これはエラーメッセージ内でコードを識別するためだけのものです) を :c:"

"func:`PyRun_SimpleFile` に渡す、といった具合です。これまでの各章で説明した低"

"水準の操作を呼び出して、Python オブジェクトを構築したり使用したりもできます。"

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

msgid ":ref:`c-api-index`"

msgstr ":ref:`c-api-index`"

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

msgid ""

"The details of Python's C interface are given in this manual. A great deal "

"of necessary information can be found here."

msgstr ""

"Python C インターフェースの詳細はこのマニュアルに書かれています。必要な情報の"

"大部分はここにあるはずです。"

#: ../../extending/embedding.rst:49

msgid "Very High Level Embedding"

msgstr "高水準の埋め込み"

#: ../../extending/embedding.rst:51

msgid ""

"The simplest form of embedding Python is the use of the very high level "

"interface. This interface is intended to execute a Python script without "

"needing to interact with the application directly. This can for example be "

"used to perform some operation on a file. ::"

msgstr ""

"Python の埋め込みの最も簡単な形式は、超高水準インターフェースの利用です。この"

"インターフェースは、アプリケーションとやり取りする必要がない Python スクリプ"

"トを実行するためのものです。例えばこれは、一つのファイル上で何らかの操作を実"

"現するのに利用できます。 ::"

#: ../../extending/embedding.rst:56

msgid ""

"#define PY_SSIZE_T_CLEAN\n"

"#include <Python.h>\n"

"\n"

"int\n"

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

"{\n"

" PyStatus status;\n"

" PyConfig config;\n"

" PyConfig_InitPythonConfig(&config);\n"

"\n"

" /* optional but recommended */\n"

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

"argv[0]);\n"

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

" goto exception;\n"

" }\n"

"\n"

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

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

" goto exception;\n"

" }\n"

" PyConfig_Clear(&config);\n"

"\n"

" PyRun_SimpleString(\"from time import time,ctime\\n\"\n"

" \"print('Today is', ctime(time()))\\n\");\n"

" if (Py_FinalizeEx() < 0) {\n"

" exit(120);\n"

" }\n"

" return 0;\n"

"\n"

" exception:\n"

" PyConfig_Clear(&config);\n"

" Py_ExitStatusException(status);\n"

"}"

msgstr ""

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

msgid ""

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

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

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

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

msgstr ""

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

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

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

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

#: ../../extending/embedding.rst:97

msgid ""

"Setting :c:member:`PyConfig.program_name` should be called before :c:func:"

"`Py_InitializeFromConfig` to inform the interpreter about paths to Python "

"run-time libraries. Next, the Python interpreter is initialized with :c:"

"func:`Py_Initialize`, followed by the execution of a hard-coded Python "

"script that prints the date and time. Afterwards, the :c:func:"

"`Py_FinalizeEx` call shuts the interpreter down, followed by the end of the "

"program. In a real program, you may want to get the Python script from "

"another source, perhaps a text-editor routine, a file, or a database. "

"Getting the Python code from a file can better be done by using the :c:func:"

"`PyRun_SimpleFile` function, which saves you the trouble of allocating "

"memory space and loading the file contents."

msgstr ""

#: ../../extending/embedding.rst:112

msgid "Beyond Very High Level Embedding: An overview"

msgstr "超高水準の埋め込みから踏み出す: 概要"

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

msgid ""

"The high level interface gives you the ability to execute arbitrary pieces "

"of Python code from your application, but exchanging data values is quite "

"cumbersome to say the least. If you want that, you should use lower level "

"calls. At the cost of having to write more C code, you can achieve almost "

"anything."

msgstr ""

"高水準インターフェースは、断片的な Python コードをアプリケーションから実行で"

"きるようにしてくれますが、アプリケーションと Python コードの間でのデータのや"

"り取りは、控えめに言っても煩わしいものです。データのやり取りをしたいなら、よ"

"り低水準のインターフェース呼び出しを利用しなくてはなりません。より多く C コー"

"ドを書かねばならない代わりに、ほぼ何でもできるようになります。"

#: ../../extending/embedding.rst:119

msgid ""

"It should be noted that extending Python and embedding Python is quite the "

"same activity, despite the different intent. Most topics discussed in the "

"previous chapters are still valid. To show this, consider what the extension "

"code from Python to C really does:"

msgstr ""

"Python の拡張と埋め込みは、趣旨こそ違え、同じ作業であるということに注意せねば"

"なりません。これまでの章で議論してきたトピックのほとんどが埋め込みでもあては"

"まります。これを示すために、 Python から C への拡張を行うコードが実際には何を"

"するか考えてみましょう:"

#: ../../extending/embedding.rst:124

msgid "Convert data values from Python to C,"

msgstr "データ値を Python から C に変換する。"

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

msgid "Perform a function call to a C routine using the converted values, and"

msgstr "変換された値を使って C ルーチンの関数呼び出しを行い、"

#: ../../extending/embedding.rst:128

msgid "Convert the data values from the call from C to Python."

msgstr "呼び出しで得られたデータ値 C から Python に変換する。"

#: ../../extending/embedding.rst:130

msgid "When embedding Python, the interface code does:"

msgstr ""

"Python を埋め込む場合には、インターフェースコードが行う作業は以下のようになり"

"ます:"

#: ../../extending/embedding.rst:132

msgid "Convert data values from C to Python,"

msgstr "データ値を C から Python に変換する。"

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

msgid ""

"Perform a function call to a Python interface routine using the converted "

"values, and"

msgstr ""

"変換された値を使って Python インターフェースルーチンの関数呼び出しを行い、"

#: ../../extending/embedding.rst:137

msgid "Convert the data values from the call from Python to C."

msgstr "呼び出しで得られたデータ値 Python から C に変換する。"

#: ../../extending/embedding.rst:139

msgid ""

"As you can see, the data conversion steps are simply swapped to accommodate "

"the different direction of the cross-language transfer. The only difference "

"is the routine that you call between both data conversions. When extending, "

"you call a C routine, when embedding, you call a Python routine."

msgstr ""

"一見して分かるように、データ変換のステップは、言語間でデータを転送する方向が"

"変わったのに合わせて単に入れ替えただけです。唯一の相違点は、データ変換の間に"

"あるルーチンです。拡張を行う際には C ルーチンを呼び出しますが、埋め込みの際に"

"は Python ルーチンを呼び出します。"

#: ../../extending/embedding.rst:144

msgid ""

"This chapter will not discuss how to convert data from Python to C and vice "

"versa. Also, proper use of references and dealing with errors is assumed to "

"be understood. Since these aspects do not differ from extending the "

"interpreter, you can refer to earlier chapters for the required information."

msgstr ""

"この章では、Python から C へ、そしてその逆へとデータを変換する方法については"

"議論しません。また、正しい参照の使い方やエラーの扱い方についてすでに理解して"

"いるものと仮定します。これらの側面についてはインタプリタの拡張と何ら変わると"

"ころがないので、必要な情報については以前の章を参照できます。"

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

msgid "Pure Embedding"

msgstr "純粋な埋め込み"

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

msgid ""

"The first program aims to execute a function in a Python script. Like in the "

"section about the very high level interface, the Python interpreter does not "

"directly interact with the application (but that will change in the next "

"section)."

msgstr ""

"最初に例示するプログラムは、Python スクリプト内の関数を実行するためのもので"

"す。超高水準インターフェースに関する節で挙げた例と同様に、Python インタプリタ"

"はアプリケーションと直接やりとりはしません (が、次の節でやりとりするよう変更"

"します)。"

#: ../../extending/embedding.rst:160

msgid "The code to run a function defined in a Python script is:"

msgstr ""

"Python スクリプト内で定義されている関数を実行するためのコードは以下のようにな"

"ります:"

#: ../../extending/embedding.rst:162

msgid ""

"#define PY_SSIZE_T_CLEAN\n"

"#include <Python.h>\n"

"\n"

"int\n"

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

"{\n"

" PyObject *pName, *pModule, *pFunc;\n"

" PyObject *pArgs, *pValue;\n"

" int i;\n"

"\n"

" if (argc < 3) {\n"

" fprintf(stderr,\"Usage: call pythonfile funcname [args]\\n\");\n"

" return 1;\n"

" }\n"

"\n"

" Py_Initialize();\n"

" pName = PyUnicode_DecodeFSDefault(argv[1]);\n"

" /* Error checking of pName left out */\n"

"\n"

" pModule = PyImport_Import(pName);\n"

" Py_DECREF(pName);\n"

"\n"

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

" pFunc = PyObject_GetAttrString(pModule, argv[2]);\n"

" /* pFunc is a new reference */\n"

"\n"

" if (pFunc && PyCallable_Check(pFunc)) {\n"

" pArgs = PyTuple_New(argc - 3);\n"

" for (i = 0; i < argc - 3; ++i) {\n"

" pValue = PyLong_FromLong(atoi(argv[i + 3]));\n"

" if (!pValue) {\n"

" Py_DECREF(pArgs);\n"

" Py_DECREF(pModule);\n"

" fprintf(stderr, \"Cannot convert argument\\n\");\n"

" return 1;\n"

" }\n"

" /* pValue reference stolen here: */\n"

" PyTuple_SetItem(pArgs, i, pValue);\n"

" }\n"

" pValue = PyObject_CallObject(pFunc, pArgs);\n"

" Py_DECREF(pArgs);\n"

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

" printf(\"Result of call: %ld\\n\", PyLong_AsLong(pValue));\n"

" Py_DECREF(pValue);\n"

" }\n"

" else {\n"

" Py_DECREF(pFunc);\n"

" Py_DECREF(pModule);\n"

" PyErr_Print();\n"

" fprintf(stderr,\"Call failed\\n\");\n"

" return 1;\n"

" }\n"

" }\n"

" else {\n"

" if (PyErr_Occurred())\n"

" PyErr_Print();\n"

" fprintf(stderr, \"Cannot find function \\\"%s\\\"\\n\", "

"argv[2]);\n"

" }\n"

" Py_XDECREF(pFunc);\n"

" Py_DECREF(pModule);\n"

" }\n"

" else {\n"

" PyErr_Print();\n"

" fprintf(stderr, \"Failed to load \\\"%s\\\"\\n\", argv[1]);\n"

" return 1;\n"

" }\n"

" if (Py_FinalizeEx() < 0) {\n"

" return 120;\n"

" }\n"

" return 0;\n"

"}\n"

msgstr ""

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

msgid ""

"This code loads a Python script using ``argv[1]``, and calls the function "

"named in ``argv[2]``. Its integer arguments are the other values of the "

"``argv`` array. If you :ref:`compile and link <compiling>` this program "

"(let's call the finished executable :program:`call`), and use it to execute "

"a Python script, such as:"

msgstr ""

"このコードは ``argv[1]`` を使って Python スクリプトをロードし、 ``argv[2]`` "

"内に指定された名前の関数を呼び出します。関数の整数引数は ``argv`` 配列中の他"

"の値になります。このプログラムを :ref:`コンパイルしてリンク <compiling>` し "

"(できた実行可能形式を :program:`call` と呼びましょう)、以下のような Python ス"

"クリプトを実行することにします:"

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

msgid ""

"def multiply(a,b):\n"

" print(\"Will compute\", a, \"times\", b)\n"

" c = 0\n"

" for i in range(0, a):\n"

" c = c + b\n"

" return c"

msgstr ""

#: ../../extending/embedding.rst:180

msgid "then the result should be:"

msgstr "実行結果は以下のようになるはずです:"

#: ../../extending/embedding.rst:182

msgid ""

"$ call multiply multiply 3 2\n"

"Will compute 3 times 2\n"

"Result of call: 6"

msgstr ""

#: ../../extending/embedding.rst:188

msgid ""

"Although the program is quite large for its functionality, most of the code "

"is for data conversion between Python and C, and for error reporting. The "

"interesting part with respect to embedding Python starts with ::"

msgstr ""

"この程度の機能を実現するにはプログラムがいささか大きすぎますが、ほとんどは "

"Python から C へのデータ変換やエラー報告のためのコードです。Python の埋め込み"

"という観点から最も興味深い部分は以下のコードから始まる部分です::"

#: ../../extending/embedding.rst:192

msgid ""

"Py_Initialize();\n"

"pName = PyUnicode_DecodeFSDefault(argv[1]);\n"

"/* Error checking of pName left out */\n"

"pModule = PyImport_Import(pName);"

msgstr ""

#: ../../extending/embedding.rst:197

msgid ""

"After initializing the interpreter, the script is loaded using :c:func:"

"`PyImport_Import`. This routine needs a Python string as its argument, "

"which is constructed using the :c:func:`PyUnicode_DecodeFSDefault` data "

"conversion routine. ::"

msgstr ""

#: ../../extending/embedding.rst:202

msgid ""

"pFunc = PyObject_GetAttrString(pModule, argv[2]);\n"

"/* pFunc is a new reference */\n"

"\n"

"if (pFunc && PyCallable_Check(pFunc)) {\n"

" ...\n"

"}\n"

"Py_XDECREF(pFunc);"

msgstr ""

#: ../../extending/embedding.rst:210

msgid ""

"Once the script is loaded, the name we're looking for is retrieved using :c:"

"func:`PyObject_GetAttrString`. If the name exists, and the object returned "

"is callable, you can safely assume that it is a function. The program then "

"proceeds by constructing a tuple of arguments as normal. The call to the "

"Python function is then made with::"

msgstr ""

"ひとたびスクリプトが読み込まれると、 :c:func:`PyObject_GetAttrString` を使っ"

"て必要な名前を取得できます。名前がスクリプト中に存在し、取得したオブジェクト"

"が呼び出し可能オブジェクトであれば、このオブジェクトが関数であると考えて差し"

"支えないでしょう。そこでプログラムは定石どおりに引数のタプル構築に進みます。"

"その後、Python 関数を以下のコードで呼び出します::"

#: ../../extending/embedding.rst:216

msgid "pValue = PyObject_CallObject(pFunc, pArgs);"

msgstr ""

#: ../../extending/embedding.rst:218

msgid ""

"Upon return of the function, ``pValue`` is either ``NULL`` or it contains a "

"reference to the return value of the function. Be sure to release the "

"reference after examining the value."

msgstr ""

"関数が処理を戻す際、 ``pValue`` は ``NULL`` になるか、関数の戻り値への参照が"

"入っています。値を調べた後には忘れずに参照を解放してください。"

#: ../../extending/embedding.rst:226

msgid "Extending Embedded Python"

msgstr "埋め込まれた Python の拡張"

#: ../../extending/embedding.rst:228

msgid ""

"Until now, the embedded Python interpreter had no access to functionality "

"from the application itself. The Python API allows this by extending the "

"embedded interpreter. That is, the embedded interpreter gets extended with "

"routines provided by the application. While it sounds complex, it is not so "

"bad. Simply forget for a while that the application starts the Python "

"interpreter. Instead, consider the application to be a set of subroutines, "

"and write some glue code that gives Python access to those routines, just "

"like you would write a normal Python extension. For example::"

msgstr ""

"ここまでは、埋め込み Python インタプリタはアプリケーション本体の機能にアクセ"

"スする手段がありませんでした。 Python API を使うと、埋め込みインタプリタを拡"

"張することでアプリケーション本体へのアクセスを可能にします。つまり、アプリ"

"ケーションで提供されているルーチンを使って、埋め込みインタプリタを拡張するの"

"です。複雑なことのように思えますが、それほどひどいわけではありません。さしあ"

"たって、アプリケーションが Python インタプリタを起動したということをちょっと"

"忘れてみてください。その代わり、アプリケーションがサブルーチンの集まりで、あ"

"たかも普通の Python 拡張モジュールを書くかのように、Python から各ルーチンにア"

"クセスできるようにするグルー(glue, 糊) コードを書くと考えてください。例えば以"

"下のようにです::"

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

msgid ""

"static int numargs=0;\n"

"\n"

"/* Return the number of arguments of the application command line */\n"

"static PyObject*\n"

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

"{\n"

" if(!PyArg_ParseTuple(args, \":numargs\"))\n"

" return NULL;\n"

" return PyLong_FromLong(numargs);\n"

"}\n"

"\n"

"static PyMethodDef emb_module_methods[] = {\n"

" {\"numargs\", emb_numargs, METH_VARARGS,\n"

" \"Return the number of arguments received by the process.\"},\n"

" {NULL, NULL, 0, NULL}\n"

"};\n"

"\n"

"static struct PyModuleDef emb_module = {\n"

" .m_base = PyModuleDef_HEAD_INIT,\n"

" .m_name = \"emb\",\n"

" .m_size = 0,\n"

" .m_methods = emb_module_methods,\n"

"};\n"

"\n"

"static PyObject*\n"

"PyInit_emb(void)\n"

"{\n"

" return PyModuleDef_Init(&emb_module);\n"

"}"

msgstr ""

#: ../../extending/embedding.rst:267

msgid ""

"Insert the above code just above the :c:func:`main` function. Also, insert "

"the following two statements before the call to :c:func:`Py_Initialize`::"

msgstr ""

"上のコードを :c:func:`main` 関数のすぐ上に挿入します。また、以下の二つの文"

"を :c:func:`Py_Initialize` の呼び出しの前に挿入します::"

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

msgid ""

"numargs = argc;\n"

"PyImport_AppendInittab(\"emb\", &PyInit_emb);"

msgstr ""

#: ../../extending/embedding.rst:273

msgid ""

"These two lines initialize the ``numargs`` variable, and make the :func:`!"

"emb.numargs` function accessible to the embedded Python interpreter. With "

"these extensions, the Python script can do things like"

msgstr ""

#: ../../extending/embedding.rst:277

msgid ""

"import emb\n"

"print(\"Number of arguments\", emb.numargs())"

msgstr ""

#: ../../extending/embedding.rst:282

msgid ""

"In a real application, the methods will expose an API of the application to "

"Python."

msgstr ""

"実際のアプリケーションでは、こうしたメソッドでアプリケーション内の API を "

"Python に公開することになります。"

#: ../../extending/embedding.rst:292

msgid "Embedding Python in C++"

msgstr "C++による Python の埋め込み"

#: ../../extending/embedding.rst:294

msgid ""

"It is also possible to embed Python in a C++ program; precisely how this is "

"done will depend on the details of the C++ system used; in general you will "

"need to write the main program in C++, and use the C++ compiler to compile "

"and link your program. There is no need to recompile Python itself using C+"

"+."

msgstr ""

"C++ プログラム中にも Python を埋め込めます; 厳密に言うと、どうやって埋め込む"

"かは使っているC++ 処理系の詳細に依存します; 一般的には、メインプログラムをC+"

"+で書き、C++ コンパイラを使ってプログラムをコンパイル・リンクする必要があるで"

"しょう。 Python 自体を C++でコンパイルしなおす必要はありません。"

#: ../../extending/embedding.rst:303

msgid "Compiling and Linking under Unix-like systems"

msgstr "Unix 系システムにおけるコンパイルとリンク"

#: ../../extending/embedding.rst:305

msgid ""

"It is not necessarily trivial to find the right flags to pass to your "

"compiler (and linker) in order to embed the Python interpreter into your "

"application, particularly because Python needs to load library modules "

"implemented as C dynamic extensions (:file:`.so` files) linked against it."

msgstr ""

"Python インタプリタをアプリケーションに埋め込むためにコンパイラ (とリンカ) に"

"渡すべき正しいフラグを見出すのは簡単でないかもしれません。これは特に、Python "

"がライブラリモジュールに対してリンクされた C 動的拡張 (:file:`.so` ファイル) "

"として実装されたものをロードする必要があるためです。"

#: ../../extending/embedding.rst:311

msgid ""

"To find out the required compiler and linker flags, you can execute the :"

"file:`python{X.Y}-config` script which is generated as part of the "

"installation process (a :file:`python3-config` script may also be "

"available). This script has several options, of which the following will be "

"directly useful to you:"

msgstr ""

"必要なコンパイル・リンクのオプションを知るために、 :file:`python{X.Y}-"

"config` スクリプトが使えます(これは Python インストール時に生成されたもの"

"で、 :file:`python3-config` スクリプトも利用出来るかもしれません)。このスクリ"

"プトにはオプションが多くありますが、直接的に有用なのはこれでしょう:"

#: ../../extending/embedding.rst:317

msgid ""

"``pythonX.Y-config --cflags`` will give you the recommended flags when "

"compiling:"

msgstr ""

"``pythonX.Y-config --cflags`` は推奨のコンパイルオプションを出力します:"

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

msgid ""

"$ /opt/bin/python3.11-config --cflags\n"

"-I/opt/include/python3.11 -I/opt/include/python3.11 -Wsign-compare -DNDEBUG "

"-g -fwrapv -O3 -Wall"

msgstr ""

#: ../../extending/embedding.rst:325

msgid ""

"``pythonX.Y-config --ldflags --embed`` will give you the recommended flags "

"when linking:"

msgstr ""

"``pythonX.Y-config --ldflags --embed`` は推奨のリンクオプションを出力します:"

#: ../../extending/embedding.rst:328

msgid ""

"$ /opt/bin/python3.11-config --ldflags --embed\n"

"-L/opt/lib/python3.11/config-3.11-x86_64-linux-gnu -L/opt/lib -lpython3.11 -"

"lpthread -ldl -lutil -lm"

msgstr ""

#: ../../extending/embedding.rst:334

msgid ""

"To avoid confusion between several Python installations (and especially "

"between the system Python and your own compiled Python), it is recommended "

"that you use the absolute path to :file:`python{X.Y}-config`, as in the "

"above example."

msgstr ""

"複数 Python バージョン共存(とりわけシステムの Python とあなた自身でビルドし"

"た Python)での混乱を避けるために、上での例のように :file:`python{X.Y}-"

"config` は絶対パスで起動したほうが良いです。"

#: ../../extending/embedding.rst:339

msgid ""

"If this procedure doesn't work for you (it is not guaranteed to work for all "

"Unix-like platforms; however, we welcome :ref:`bug reports <reporting-"

"bugs>`) you will have to read your system's documentation about dynamic "

"linking and/or examine Python's :file:`Makefile` (use :func:`sysconfig."

"get_makefile_filename` to find its location) and compilation options. In "

"this case, the :mod:`sysconfig` module is a useful tool to programmatically "

"extract the configuration values that you will want to combine together. "

"For example:"

msgstr ""

"もしこの手順でうまくいかなければ(たしかにこれは全ての Unix 的なプラットフォー"

"ムで動作することを保障するものではないですが、 :ref:`bug reports <reporting-"

"bugs>` は歓迎です)、あなたのシステムのダイナミックリンクについてのドキュメン"

"トを読み、Python の :file:`Makefile` のコンパイルオプションを調べる必要がある"

"でしょう(Makefile の場所を調べるには :func:`sysconfig.get_makefile_filename` "

"を使ってください)。この場合、 :mod:`sysconfig` モジュールが役に立つ道具になり"

"ます。これによってあなたが付け加えたいコンパイル・リンクのオプション構成をプ"

"ログラム的に抽出できます。例えば:"

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

msgid ""

">>> import sysconfig\n"

">>> sysconfig.get_config_var('LIBS')\n"

"'-lpthread -ldl -lutil'\n"

">>> sysconfig.get_config_var('LINKFORSHARED')\n"

"'-Xlinker -export-dynamic'"

msgstr ""