名前¶

perliol - IO 層の Perl 実装への C API

(訳注: (TBR)がついている段落は「みんなの自動翻訳＠TexTra」による 機械翻訳です。)

概要¶

    /* Defining a layer ... */
    #include <perliol.h>

説明¶

この文書は、USE_PERLIO が定義されている(そして USE_SFIO が 定義されていない)場合に perlapio で記述されている PerlIO 抽象化の 振る舞いと実装について記述しています。

歴史と背景¶

PerlIO抽象化はperl5.003_02で導入されましたが、perl5.7.0までは単なる抽象化として低迷していました。 しかし、その間に多くのperl拡張がそれを使用するように切り替えられたので、APIは(ソース)互換性を維持するためにほとんど固定されています。 (TBR)

この実装の目的は、柔軟でプラットフォームに中立な方法でPerlIO APIを提供することです。 また、Perl 6に適用できる「オブジェクト指向C(vtablesを使用)」アプローチの試行でもあります。 (TBR)

基本構造¶

PerlIO は層のスタックです。

下位レベルのスタックは、下位レベルのオペレーティングシステムコール(Cのファイル記述子)と連動してバイトを入出力し、上位層のスタックバッファー、フィルター、その他の方法で入出力を操作し、文字(またはバイト)をPerlに返します。 aboveおよびbelowという用語は、スタック層の相対的な位置を示すために使用されます。 (TBR)

層には、"vtable"、I/O操作のテーブル(Cレベルでは関数ポインタのテーブル)、およびステータスフラグが含まれます。 vtable内の関数は、"open"、"read"、"write"などの操作を実装します。 (TBR)

I/O(たとえば「read」)が要求されると、要求はまずPerlから各層の「read」関数を使用してスタックに送られ、次に一番下でオペレーティングシステムサービスからの入力が要求され、その結果がスタックに戻され、最終的にPerlデータとして解釈されます。 (TBR)

要求は必ずしも常にオペレーティングシステムまで届くわけではありません。 そこでPerlIOバッファリングが機能します。 (TBR)

open()を実行し、デプロイする追加のPerlIO層を指定すると、指定した層は既存のデフォルトスタックの上に「プッシュ」されます。 これを理解する1つの方法は、「オペレーティングシステムが左側にあり」、「Perlが右側にある」ということです。 (TBR)

このデフォルトスタックにどの層が含まれるかは、オペレーティングシステム、Perlのバージョン、Perlコンパイル時の設定、Perlランタイムの設定など、さまざまな要素によって異なります。 詳細については、PerlIO、"PERLIO" in perlrun、およびopenを参照してください。 (TBR)

binmode()はopen()と同様に動作します。 デフォルトでは、指定された層が既存のスタックの上にプッシュされます。 (TBR)

ただし、指定された層がopen()とbinmode()で"一番上にプッシュ"されていても、効果が"一番上"に限定されているわけではないことに注意してください:PerlIO層は非常に'アクティブ'であり、スタック内のより深い層も検査して影響を与えることができます。 一例として、"raw"と呼ばれる層があり、バイナリデータを処理できると宣言された最初の層に到達するまで層を繰り返し"ポップ"します。 "プッシュ"された層は左から右の順に処理されます。 (TBR)

例えば、UNIXやUNIXに似たシステムでは、sysopen()はファイル記述子のレベルで直接動作します。 PerlIO層に関しては、"unix"層のみを使用します。 "unix"層はUNIXファイル記述子の上の薄いラッパーです。 (TBR)

層とディシプリン¶

IOストリームの振る舞いを変更する機能についての最初の議論では、追加されたエンティティに"discipline"という用語が使われていましたが、これは"sfio"という用語が使われていたことに由来すると思います。 この用語はUnix端末の"line discipline"から借用したものです。 ただし、このドキュメント(およびCコード)では"layer"という用語を使用しています。 (TBR)

これは、実装された場合の自然な用語であることを願っており、かなり異なるものに対する「規律」の初期の使用に内在する含意を避けるべきである。 (TBR)

データ構造体¶

基本データ構造体は PerlIOl です:

        typedef struct _PerlIO PerlIOl;
        typedef struct _PerlIO_funcs PerlIO_funcs;
        typedef PerlIOl *PerlIO;

        struct _PerlIO
        {
         PerlIOl *      next;       /* Lower layer */
         PerlIO_funcs * tab;        /* Functions for this layer */
         IV             flags;      /* Various flags for state */
        };

PerlIOl *は構造体へのポインタであり、アプリケーションレベルPerlIO *はPerlIOl *へのポインタ、つまり構造体へのポインタへのポインタです。 これにより、実際のPerlIOl *が変化しても、アプリケーションレベルPerlIO *は一定に保たれます(PerlのSV *と比較してください。 PerlのSV *は、スカラの型が変化するにつれてsv_anyフィールドが変化します)。 IOストリームは一般に、この「層」のリンクリストへのポインタとして表現されます。 (TBR)

PerlIO *における二重の間接化のために、&(perlio->next)>>"は"PerlIO *であり、したがって、少なくとも1つの層は、ある程度まで、次の層の"標準"アプリケーションプログラミングインターフェイスを使用することができることに注意してください。 (TBR)

一つの「層」は二つの部分から構成されます:

1. The functions and attributes of the "layer class".

   「層クラス」の関数と属性。

2. The per-instance data for a particular handle.

   特定のハンドルのためのインスタンス単位のデータ。

関数と属性¶

関数と属性にアクセスするには、PerlIOlの"tab"(テーブル用)メンバを使用します。 関数(層"class"のメソッド)は固定されており、PerlIO_funcs型で定義されます。 これらは、パブリックPerlIO_xxxxx関数とほぼ同じです。 (TBR)

  struct _PerlIO_funcs
  {
   Size_t               fsize;
   char *               name;
   Size_t               size;
   IV           kind;
   IV           (*Pushed)(pTHX_ PerlIO *f,const char *mode,SV *arg, PerlIO_funcs *tab);
   IV           (*Popped)(pTHX_ PerlIO *f);
   PerlIO *     (*Open)(pTHX_ PerlIO_funcs *tab,
                        PerlIO_list_t *layers, IV n,
                        const char *mode,
                        int fd, int imode, int perm,
                        PerlIO *old,
                        int narg, SV **args);
   IV           (*Binmode)(pTHX_ PerlIO *f);
   SV *         (*Getarg)(pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
   IV           (*Fileno)(pTHX_ PerlIO *f);
   PerlIO *     (*Dup)(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
   /* Unix-like functions - cf sfio line disciplines */
   SSize_t      (*Read)(pTHX_ PerlIO *f, void *vbuf, Size_t count);
   SSize_t      (*Unread)(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
   SSize_t      (*Write)(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
   IV           (*Seek)(pTHX_ PerlIO *f, Off_t offset, int whence);
   Off_t        (*Tell)(pTHX_ PerlIO *f);
   IV           (*Close)(pTHX_ PerlIO *f);
   /* Stdio-like buffered IO functions */
   IV           (*Flush)(pTHX_ PerlIO *f);
   IV           (*Fill)(pTHX_ PerlIO *f);
   IV           (*Eof)(pTHX_ PerlIO *f);
   IV           (*Error)(pTHX_ PerlIO *f);
   void         (*Clearerr)(pTHX_ PerlIO *f);
   void         (*Setlinebuf)(pTHX_ PerlIO *f);
   /* Perl's snooping functions */
   STDCHAR *    (*Get_base)(pTHX_ PerlIO *f);
   Size_t       (*Get_bufsiz)(pTHX_ PerlIO *f);
   STDCHAR *    (*Get_ptr)(pTHX_ PerlIO *f);
   SSize_t      (*Get_cnt)(pTHX_ PerlIO *f);
   void         (*Set_ptrcnt)(pTHX_ PerlIO *f,STDCHAR *ptr,SSize_t cnt);
  };

構造体の最初の数メンバは、層の互換性チェック"name"のための関数テーブルサイズ、インスタンス単位のデータのためのmallocへのサイズ、クラス全体の属性であるいくつかのフラグ(バッファ層かどうかなど)を与え、次の4つの基本グループに分類される関数に従います。 (TBR)

1. Opening and setup functions

   オープンと設定のための関数

2. Basic IO operations

   基本 IO 操作

3. Stdio class buffering options.

   Stdio クラスバッファリングオプション。

4. Functions to support Perl's traditional "fast" access to the buffer.

   Perl の伝統的なバッファへの「高速」アクセスに対応する関数。

層はすべての関数を実装する必要はありませんが、テーブル全体が存在する必要があります。 実装されていないスロットはNULL(エラーコール時が発生します)、または"ベースクラス"から動作を"継承"するためのスタブで埋めることができます。 この"継承"は層のすべてのインスタンスに対して固定されていますが、層がテーブルに格納するスタブを選択するため、"多重継承"は制限されます。 (TBR)

インスタンス単位のデータ¶

インスタンス単位のデータは、PerlIOlを層構造体の最初のメンバにすることによって、基本的なPerlIOl構造体以外のメモリに保持される。 (TBR)

        typedef struct
        {
         struct _PerlIO base;       /* Base "class" info */
         STDCHAR *      buf;        /* Start of buffer */
         STDCHAR *      end;        /* End of valid part of buffer */
         STDCHAR *      ptr;        /* Current position in buffer */
         Off_t          posn;       /* Offset of buf into the file */
         Size_t         bufsiz;     /* Real size of buffer */
         IV             oneword;    /* Emergency buffer */
        } PerlIOBuf;

このようにして(perlのスカラと同様に)PerlIOBufへのポインタをPerlIOlへのポインタとして扱うことができます。 (TBR)

実行中の層¶

                table           perlio          unix
            |           |
            +-----------+    +----------+    +--------+
   PerlIO ->|           |--->|  next    |--->|  NULL  |
            +-----------+    +----------+    +--------+
            |           |    |  buffer  |    |   fd   |
            +-----------+    |          |    +--------+
            |           |    +----------+

上記では、単純なケースで層スキームがどのように機能するかを示します。 アプリケーションのPerlIO *は、オープン(割り当てられた)ハンドルを表すテーブルのエントリを指します。 たとえば、テーブルの最初の3つのスロットは、stdin、stdout、stderrに対応します。 テーブルは次にハンドルの現在の"最上位"層(この場合は汎用バッファ層"perlio"のインスタンス)を指します。 この層は次に下の層(この場合は低レベル"unix"層)を指します。 (TBR)

上記は"stdio"バッファストリームとほぼ同じですが、より柔軟性があります: (TBR)

• If Unix level read/write/lseek is not appropriate for (say) sockets then the "unix" layer can be replaced (at open time or even dynamically) with a "socket" layer.

  もしUnixレベルのread/write/lseekが(例えば)ソケットに適切でないなら、"unix"層は(オープン時あるいは動的に)"socket"層に置き換えることができます。 (TBR)

• Different handles can have different buffering schemes. The "top" layer could be the "mmap" layer if reading disk files was quicker using mmap than read. An "unbuffered" stream can be implemented simply by not having a buffer layer.

  異なるハンドルは異なるバッファリングスキームを持つことができます。 ディスクファイルの読み込みがreadよりmmapを使用した方が速い場合、"top"層は"mmap"層になる可能性があります。 "unbuffered"ストリームは単にバッファ層を持たないことで実装できます。 (TBR)

• Extra layers can be inserted to process the data as it flows through. This was the driving need for including the scheme in perl 5.7.0+ - we needed a mechanism to allow data to be translated between perl's internal encoding (conceptually at least Unicode as UTF-8), and the "native" format used by the system. This is provided by the ":encoding(xxxx)" layer which typically sits above the buffering layer.

  データが流れるときにデータを処理するために、追加の層を挿入することができます。 これは、perl 5.7.0+にスキームを含めるための原動力となった要求でした-perlの内部エンコーディング(概念的には少なくともUTF-8としてのUnicode)とシステムで使用される"ネイティブ"フォーマットとの間でデータを変換できるメカニズムが必要でした。 これは、一般的にバッファ層の上に位置する":encoding(xxxx)"層によって提供されます。 (TBR)

• A layer can be added that does "\n" to CRLF translation. This layer can be used on any platform, not just those that normally do such things.

  "\n"をCRLF変換に行う層を追加できます。 この層は、通常そのようなことを行うプラットフォームだけでなく、あらゆるプラットフォームで使用できます。 (TBR)

インスタンス単位のフラグビット¶

一般的なフラグビットは、PerlIO_open()に渡されたモード文字列から推定されたO_XXXXXスタイルフラグと、典型的なバッファ層の状態ビットとのハイブリッドである。 (TBR)

PERLIO_F_EOF

End of file.

ファイルの末尾。

PERLIO_F_CANWRITE

Writes are permitted, i.e. opened as "w" or "r+" or "a", etc.

書き込みが許可されている; つまり "w", "r+", "a" などとして開かれている。

PERLIO_F_CANREAD

Reads are permitted i.e. opened "r" or "w+" (or even "a+" - ick).

読み込みが許可されている; "r", "w+" (または "a+" 的) として開かれている。

PERLIO_F_ERROR

An error has occurred (for PerlIO_error()).

(PerlIO_error() のための) エラーが発生した。

PERLIO_F_TRUNCATE

Truncate file suggested by open mode.

オープンモードで提案されたファイルを切り詰める。

PERLIO_F_APPEND

All writes should be appends.

全ての書き込みは追記される。

PERLIO_F_CRLF

Layer is performing Win32-like "\n" mapped to CR,LF for output and CR,LF mapped to "\n" for input. Normally the provided "crlf" layer is the only layer that need bother about this. PerlIO_binmode() will mess with this flag rather than add/remove layers if the PERLIO_K_CANCRLF bit is set for the layers class.

層はWin 32のような"\n"を実行しています。 "\n"は出力用にCR,LFにマップされ、CR,LFは入力用に"\n"にマップされます。 通常、"crlf"層が提供されていますが、これを気にする必要がある層はこれだけです。 PerlIO_K_CANCRLFビットが層クラスに設定されている場合、PERLIO_binmode()は層を追加/削除するのではなく、このフラグを扱います。 (TBR)

PERLIO_F_UTF8

Data written to this layer should be UTF-8 encoded; data provided by this layer should be considered UTF-8 encoded. Can be set on any layer by ":utf8" dummy layer. Also set on ":encoding" layer.

この層に書き込まれるデータはUTF-8エンコードされている必要があります。 この層によって提供されるデータはUTF-8エンコードされているとみなされます。 ":utf8"ダミー層によって任意の層に設定できます。 ":encoding"層にも設定できます。 (TBR)

PERLIO_F_UNBUF

Layer is unbuffered - i.e. write to next layer down should occur for each write to this layer.

層はバッファされていません。 つまり、次の層への書き込みは、この層への書き込みごとに行われます。 (TBR)

PERLIO_F_WRBUF

The buffer for this layer currently holds data written to it but not sent to next layer.

現在、この層のバッファには、書き込まれたデータが保持されますが、次の層には送信されません。 (TBR)

PERLIO_F_RDBUF

The buffer for this layer currently holds unconsumed data read from layer below.

現在、この層のバッファには、下の層から読み込まれた未使用データが保持されています。 (TBR)

PERLIO_F_LINEBUF

Layer is line buffered. Write data should be passed to next layer down whenever a "\n" is seen. Any data beyond the "\n" should then be processed.

層はラインバッファされています。 "\n"が検出された場合、書き込みデータは次の画層に渡される必要があります。 "\n"を超えるデータは処理されます。 (TBR)

PERLIO_F_TEMP

File has been unlink()ed, or should be deleted on close().

ファイルが unlink() されている、または close() で削除されるべき。

PERLIO_F_OPEN

Handle is open.

ハンドルが開いている。

PERLIO_F_FASTGETS

This instance of this layer supports the "fast gets" interface. Normally set based on PERLIO_K_FASTGETS for the class and by the existence of the function(s) in the table. However a class that normally provides that interface may need to avoid it on a particular instance. The "pending" layer needs to do this when it is pushed above a layer which does not support the interface. (Perl's sv_gets() does not expect the streams fast gets behaviour to change during one "get".)

この層のこのインスタンスは"fast gets"インタフェースをサポートします。 通常は、クラスのPERLIO_K_FASTGETSとテーブル内の関数の存在に基づいて設定されます。 しかし、通常そのインタフェースを提供するクラスは、特定のインスタンスでそのインタフェースを回避する必要があるかもしれません。 "pending"層は、そのインタフェースをサポートしない層の上にプッシュされたときに、これを行う必要があります。 (Perlのsv_gets()は、"get"の間にストリームの高速なgets動作が変化することを期待していません。 ) (TBR)

メソッドの詳細¶

fsize

        Size_t fsize;

Size of the function table. This is compared against the value PerlIO code "knows" as a compatibility check. Future versions may be able to tolerate layers compiled against an old version of the headers.

ファンクションテーブルのサイズ。 これは互換性チェックとしてPerlIOコードが「知っている」値と比較されます。 将来のバージョンでは、古いバージョンのヘッダに対してコンパイルされた層を許容できるようになる可能性があります。 (TBR)

name

        char * name;

The name of the layer whose open() method Perl should invoke on open(). For example if the layer is called APR, you will call:

Perlがopen()で呼び出すopen()メソッドを持つ層の名前。 たとえば、層がAPRという場合は、次のようにコールします。 (TBR)

  open $fh, ">:APR", ...

and Perl knows that it has to invoke the PerlIOAPR_open() method implemented by the APR layer.

そしてPerlは、APR層によって実装されたPerlIOAPR_open()メソッドを呼び出さなければならないことを知っています。 (TBR)

size

        Size_t size;

The size of the per-instance data structure, e.g.:

インスタンス単位のデータ構造体のサイズ; つまり:

  sizeof(PerlIOAPR)

If this field is zero then PerlIO_pushed does not malloc anything and assumes layer's Pushed function will do any required layer stack manipulation - used to avoid malloc/free overhead for dummy layers. If the field is non-zero it must be at least the size of PerlIOl, PerlIO_pushed will allocate memory for the layer's data structures and link new layer onto the stream's stack. (If the layer's Pushed method returns an error indication the layer is popped again.)

このフィールドが0の場合、PerlIO_pushedは何もmallocせず、layerのPushed関数が必要な層スタック操作を行うと仮定します。 これはmalloc/freeオーバーヘッドをダミー層に対して回避するために使用されます。 フィールドが0以外の場合、少なくともPerlIOlのサイズである必要があります。 PerlIO_pushedは層のデータ構造にメモリを割り当て、新しい層をストリームのスタックにリンクします(層のPushedメソッドがエラー表示を返す場合、層は再度ポップされます)。 (TBR)

kind

        IV kind;

• PERLIO_K_BUFFERED

  The layer is buffered.

  層がバッファリングされている。

• PERLIO_K_RAW

  The layer is acceptable to have in a binmode(FH) stack - i.e. it does not (or will configure itself not to) transform bytes passing through it.

  層は、バイナリモード(FH)スタックを持つことが許容されます。 つまり、層を通過するバイトを変換しません(または、変換しないように自身を設定しません)。 (TBR)

• PERLIO_K_CANCRLF

  Layer can translate between "\n" and CRLF line ends.

  層は "\n" と CRLF 行末を変換できる。

• PERLIO_K_FASTGETS

  Layer allows buffer snooping.

  層はバッファを覗くことを許可している。

• PERLIO_K_MULTIARG

  Used when the layer's open() accepts more arguments than usual. The extra arguments should come not before the MODE argument. When this flag is used it's up to the layer to validate the args.

  層のopen()が通常より多くの引数を受け入れる場合に使用されます。 余分な引数は、MODE引数の前に指定しないでください。 このフラグを使用する場合は、層がargsを検証します。 (TBR)

Pushed

        IV      (*Pushed)(pTHX_ PerlIO *f,const char *mode, SV *arg);

The only absolutely mandatory method. Called when the layer is pushed onto the stack. The mode argument may be NULL if this occurs post-open. The arg will be non-NULL if an argument string was passed. In most cases this should call PerlIOBase_pushed() to convert mode into the appropriate PERLIO_F_XXXXX flags in addition to any actions the layer itself takes. If a layer is not expecting an argument it need neither save the one passed to it, nor provide Getarg() (it could perhaps Perl_warn that the argument was un-expected).

唯一絶対に必要なメソッドです。 層がスタックにプッシュされるときに呼び出されます。 mode引数は、オープン後に発生する場合はNULLになる可能性があります。 引数文字列が渡された場合、argは非NULLになります。 ほとんどの場合、これはPerlIOBase_pushed()を呼び出し、層自身が行うアクションに加えて、modeを適切なPERLIO_F_XXXXXフラグに変換する必要があります。 層が引数を予期していない場合は、渡された引数を保存する必要も、Getarg()を指定する必要もありません(引数が予期されていなかった場合は、Perl_warnである可能性があります)。 (TBR)

Returns 0 on success. On failure returns -1 and should set errno.

成功時は 0 を返します。 失敗時には -1 を返して errno が設定されます。

Popped

        IV      (*Popped)(pTHX_ PerlIO *f);

Called when the layer is popped from the stack. A layer will normally be popped after Close() is called. But a layer can be popped without being closed if the program is dynamically managing layers on the stream. In such cases Popped() should free any resources (buffers, translation tables, ...) not held directly in the layer's struct. It should also Unread() any unconsumed data that has been read and buffered from the layer below back to that layer, so that it can be re-provided to what ever is now above.

層がスタックからポップされるときに呼び出されます。 層は通常、Close()が呼び出された後にポップされます。 しかし、プログラムがストリーム上の層を動的に管理している場合、層は閉じずにポップされる可能性があります。 そのような場合、Pop()は、層の構造体に直接保持されていないリソース(バッファ、変換テーブルなど)を解放する必要があります。 また、下の層から読み込まれてバッファされた未使用のデータをUnread()に戻して、現在上にあるものに再度提供できるようにします。 (TBR)

Returns 0 on success and failure. If Popped() returns true then perlio.c assumes that either the layer has popped itself, or the layer is super special and needs to be retained for other reasons. In most cases it should return false.

成功および失敗時に0を戻します。 perlio()がtrueを戻した場合、Pop.cは、層が自身でポップしたか、層が超特殊で他の理由で保持する必要があると想定します。 ほとんどの場合、falseを戻します。 (TBR)

Open

        PerlIO *        (*Open)(...);

The Open() method has lots of arguments because it combines the functions of perl's open, PerlIO_open, perl's sysopen, PerlIO_fdopen and PerlIO_reopen. The full prototype is as follows:

Open()メソッドは、perlのopen、PerlIO_open、perlのsysopen、PerlIO_fdopen、PerlIO_reopenの関数を組み合わせているため、多くの引数を持っています。 完全なプロトタイプは次のとおりです。 (TBR)

 PerlIO *       (*Open)(pTHX_ PerlIO_funcs *tab,
                        PerlIO_list_t *layers, IV n,
                        const char *mode,
                        int fd, int imode, int perm,
                        PerlIO *old,
                        int narg, SV **args);

Open should (perhaps indirectly) call PerlIO_allocate() to allocate a slot in the table and associate it with the layers information for the opened file, by calling PerlIO_push. The layers is an array of all the layers destined for the PerlIO *, and any arguments passed to them, n is the index into that array of the layer being called. The macro PerlIOArg will return a (possibly NULL) SV * for the argument passed to the layer.

Openは(おそらく間接的に)PerlIO_allocate()を呼び出してテーブル内のスロットを割り当て、PerlIO_pushを呼び出して開いたファイルの層情報に関連付ける必要があります。 layersはPerlIO *宛てのすべての層の配列であり、それらに渡された引数nは呼び出された層のその配列へのインデックスです。 マクロPerlIOArgは層に渡された引数に対して(おそらくNULL)SV*を返します。 (TBR)

The mode string is an "fopen()-like" string which would match the regular expression /^[I#]?[rwa]\+?[bt]?$/.

mode文字列は、正規表現/^[I#]?[rwa]\+?[bt]?$/に一致する"fopen()様"文字列です。 (TBR)

The 'I' prefix is used during creation of stdin..stderr via special PerlIO_fdopen calls; the '#' prefix means that this is sysopen and that imode and perm should be passed to PerlLIO_open3; 'r' means read, 'w' means write and 'a' means append. The '+' suffix means that both reading and writing/appending are permitted. The 'b' suffix means file should be binary, and 't' means it is text. (Almost all layers should do the IO in binary mode, and ignore the b/t bits. The :crlf layer should be pushed to handle the distinction.)

'I'接頭辞は、特殊なPerlIO_fdopen呼び出しによるstdin.stderrの作成時に使用されます。 '#'接頭辞はこれがsysopenであり、imodeとpermがPerlLIO_open3に渡されることを意味します。 'r'はread、'w'はwrite、'a'はappendを意味します。 '+'接尾辞は読み取りと書き込み/追加の両方が許可されることを意味します。 'b'接尾辞はファイルがバイナリであることを意味し、't'はテキストであることを意味します(ほとんどすべての層はバイナリモードでIOを行い、b/tビットは無視します。 :crlf層はこの区別を処理するようにプッシュされるべきです)。 (TBR)

If old is not NULL then this is a PerlIO_reopen. Perl itself does not use this (yet?) and semantics are a little vague.

もしoldがNULLでなければ、これはPerlIO_reopenです。 Perl自体は(まだ?)これを使っておらず、セマンティクスも少し曖昧です。 (TBR)

If fd not negative then it is the numeric file descriptor fd, which will be open in a manner compatible with the supplied mode string, the call is thus equivalent to PerlIO_fdopen. In this case nargs will be zero.

fdが負でない場合、これは数値ファイルディスクリプタfdであり、指定されたモード文字列と互換性のある方法でオープンされる。 したがって、この呼び出しはPerlIO_fdopenと等価である。 この場合、nargsは0になる。 (TBR)

If nargs is greater than zero then it gives the number of arguments passed to open, otherwise it will be 1 if for example PerlIO_open was called. In simple cases SvPV_nolen(*args) is the pathname to open.

nargsが0より大きい場合は、openに渡された引数の数を返します。 そうでなければ、たとえばPerlIO_openが呼び出された場合は1になります。 単純な場合には、SvPV_nolen(*args)が開くパス名です。 (TBR)

Having said all that translation-only layers do not need to provide Open() at all, but rather leave the opening to a lower level layer and wait to be "pushed". If a layer does provide Open() it should normally call the Open() method of next layer down (if any) and then push itself on top if that succeeds.

とは言っても、変換のみの層はOpen()を提供する必要は全くなく、むしろ下位レベルの層に開口部を残し、"プッシュ"されるのを待つ必要があります。 層がOpen()を提供する場合、通常は次の層のOpen()メソッドを呼び出し(もしあれば)、成功した場合には自身を一番上にプッシュする必要があります。 (TBR)

If PerlIO_push was performed and open has failed, it must PerlIO_pop itself, since if it's not, the layer won't be removed and may cause bad problems.

PerlIO_pushが実行され、オープンが失敗した場合、それはPerlIO_pop自身でなければならない。 そうでない場合、層は削除されず、悪い問題を引き起こす可能性があるからである。 (TBR)

Returns NULL on failure.

失敗時には NULL を返します。

Binmode

        IV        (*Binmode)(pTHX_ PerlIO *f);

Optional. Used when :raw layer is pushed (explicitly or as a result of binmode(FH)). If not present layer will be popped. If present should configure layer as binary (or pop itself) and return 0. If it returns -1 for error binmode will fail with layer still on the stack.

オプション。 :raw層がプッシュされたときに使用されます(明示的に、またはbinmode(FH)の結果として)。 層が存在しない場合は、層がポップされます。 層が存在する場合は、層をバイナリ(またはポップ自体)として設定し、0を返す必要があります。 エラーで-1が返された場合、binmodeは失敗し、層はまだスタック上にあります。 (TBR)

Getarg

        SV *      (*Getarg)(pTHX_ PerlIO *f,
                            CLONE_PARAMS *param, int flags);

Optional. If present should return an SV * representing the string argument passed to the layer when it was pushed. e.g. ":encoding(ascii)" would return an SvPV with value "ascii". (param and flags arguments can be ignored in most cases)

省略可能です。 存在する場合は、層がプッシュされたときに層に渡された文字列引数を表すSV*が戻されます。 たとえば、":encoding(ascii)"は、値"ascii"のSvPVを戻します。 (paramおよびflags引数はほとんどの場合無視できます) (TBR)

Dup uses Getarg to retrieve the argument originally passed to Pushed, so you must implement this function if your layer has an extra argument to Pushed and will ever be Duped.

DupはGetargををに渡された引数を取得するためにGetargを使用します。 したがって、層にPushedへの追加引数があり、Dupされる場合は、この関数を実装する必要があります。 (TBR)

Fileno

        IV        (*Fileno)(pTHX_ PerlIO *f);

Returns the Unix/Posix numeric file descriptor for the handle. Normally PerlIOBase_fileno() (which just asks next layer down) will suffice for this.

ハンドルのUnix/Posix数値ファイル記述子を返します。 通常、これにはPerlIOBase_fileno()(単に次の層を要求する)で十分です。 (TBR)

Returns -1 on error, which is considered to include the case where the layer cannot provide such a file descriptor.

エラー時に-1を返します。 これは、層がそのようなファイル記述子を提供できない場合を含むと考えられます。 (TBR)

Dup

        PerlIO * (*Dup)(pTHX_ PerlIO *f, PerlIO *o,
                        CLONE_PARAMS *param, int flags);

XXX: Needs more docs.

XXX: もっと文書が必要です。

Used as part of the "clone" process when a thread is spawned (in which case param will be non-NULL) and when a stream is being duplicated via '&' in the open.

スレッドが生成されるとき(この場合、paramは非NULLになります)、およびストリームがopenの'&'によって複製されるときに、"clone"プロセスの一部として使用されます。 (TBR)

Similar to Open, returns PerlIO* on success, NULL on failure.

Open と同様ですが、正常時には PerlIO* を返し、失敗時には NULL を 返します。

Read

        SSize_t (*Read)(pTHX_ PerlIO *f, void *vbuf, Size_t count);

Basic read operation.

基本読み込み操作です。

Typically will call Fill and manipulate pointers (possibly via the API). PerlIOBuf_read() may be suitable for derived classes which provide "fast gets" methods.

通常、はFillを呼び出し、ポインタを操作します(おそらくアプリケーションプログラミングインターフェイス経由で)。 PerlIOBuf_read()は、"fast gets"メソッドを提供する派生クラスに適しています。 (TBR)

Returns actual bytes read, or -1 on an error.

実際に読み込まれたバイト数か、エラー時には -1 を返します。

Unread

        SSize_t (*Unread)(pTHX_ PerlIO *f,
                          const void *vbuf, Size_t count);

A superset of stdio's ungetc(). Should arrange for future reads to see the bytes in vbuf. If there is no obviously better implementation then PerlIOBase_unread() provides the function by pushing a "fake" "pending" layer above the calling layer.

stdioのungetc()のスーパーセット。 今後の読み込みでvbuf内のバイトを参照するように手配する必要があります。 明らかに優れた実装がない場合、PerlIOBase_unread()は"fake""pending"層を呼び出し元層の上にプッシュすることで関数を提供します。 (TBR)

Returns the number of unread chars.

まだ読み込んでいない文字の数を返します。

Write

        SSize_t (*Write)(PerlIO *f, const void *vbuf, Size_t count);

Basic write operation.

基本書き込み操作です。

Returns bytes written or -1 on an error.

書き込まれたバイト数か、エラー時には -1 を返します。

Seek

        IV      (*Seek)(pTHX_ PerlIO *f, Off_t offset, int whence);

Position the file pointer. Should normally call its own Flush method and then the Seek method of next layer down.

ファイルポインタを配置します。 通常は、独自のFlushメソッドを呼び出し、次の層のSeekメソッドを呼び出します。 (TBR)

Returns 0 on success, -1 on failure.

成功時には 0 を、失敗時には -1 を返します。

Tell

        Off_t   (*Tell)(pTHX_ PerlIO *f);

Return the file pointer. May be based on layers cached concept of position to avoid overhead.

ファイルポインタを返します。 オーバーヘッドを避けるために、層にキャッシュされた位置の概念に基づくことがあります。 (TBR)

Returns -1 on failure to get the file pointer.

ファイルポインタヲ得るのに失敗した場合は -1 を返します。

Close

        IV      (*Close)(pTHX_ PerlIO *f);

Close the stream. Should normally call PerlIOBase_close() to flush itself and close layers below, and then deallocate any data structures (buffers, translation tables, ...) not held directly in the data structure.

ストリームを閉じます。 通常はPerlIOBase_close()を呼び出して自身をフラッシュし、下位の層を閉じます。 次に、データ構造に直接保持されていないデータ構造(バッファ、変換テーブルなど)の割り当てを解除します。 (TBR)

Returns 0 on success, -1 on failure.

成功時には 0 を、失敗時には -1 を返します。

Flush

        IV      (*Flush)(pTHX_ PerlIO *f);

Should make stream's state consistent with layers below. That is, any buffered write data should be written, and file position of lower layers adjusted for data read from below but not actually consumed. (Should perhaps Unread() such data to the lower layer.)

ストリームの状態を下位層と一致させる必要があります。 つまり、バッファされた書き込みデータが書き込まれ、下位層のファイル位置は下位層から読み込まれたが実際には消費されないデータに合わせて調整される必要があります(おそらくそのようなデータを下位層にUnread()すべきです)。 (TBR)

Returns 0 on success, -1 on failure.

成功時には 0 を、失敗時には -1 を返します。

Fill

        IV      (*Fill)(pTHX_ PerlIO *f);

The buffer for this layer should be filled (for read) from layer below. When you "subclass" PerlIOBuf layer, you want to use its _read method and to supply your own fill method, which fills the PerlIOBuf's buffer.

この画層のバッファは、下の画層から読み込むために塗りつぶす必要があります。 PerlIOBuf画層を"サブクラス"する場合、_readメソッドを使用し、PerlIOBufのバッファを埋める独自の塗りつぶしメソッドを指定します。 (TBR)

Returns 0 on success, -1 on failure.

成功時には 0 を、失敗時には -1 を返します。

Eof

        IV      (*Eof)(pTHX_ PerlIO *f);

Return end-of-file indicator. PerlIOBase_eof() is normally sufficient.

ファイル終端指示子を返します。 普通は PerlIOBase_eof() で十分です。

Returns 0 on end-of-file, 1 if not end-of-file, -1 on error.

ファイル末尾では 0 を、ファイル末尾でなければ 1 を、エラー時には -1 を 返します。

Error

        IV      (*Error)(pTHX_ PerlIO *f);

Return error indicator. PerlIOBase_error() is normally sufficient.

エラー指示子を返します。 普通は PerlIOBase_error() で十分です。

Returns 1 if there is an error (usually when PERLIO_F_ERROR is set, 0 otherwise.

エラー (普通は PERLIO_F_ERROR がセットされている) の場合は 1、 さもなければ 0 を返します。

Clearerr

        void    (*Clearerr)(pTHX_ PerlIO *f);

Clear end-of-file and error indicators. Should call PerlIOBase_clearerr() to set the PERLIO_F_XXXXX flags, which may suffice.

ファイル終了インジケータとエラーインジケータをクリアします。 PerlIOBase_clearerr()を呼び出してPERLIO_F_XXXXXフラグを設定する必要があります。 これで十分です。 (TBR)

Setlinebuf

        void    (*Setlinebuf)(pTHX_ PerlIO *f);

Mark the stream as line buffered. PerlIOBase_setlinebuf() sets the PERLIO_F_LINEBUF flag and is normally sufficient.

PerlIOBase_setlinebuf()はPERLIO_F_LINEBUFフラグをは_F_フラグを設定し、通常はこれで十分です。 (TBR)

Get_base

        STDCHAR *       (*Get_base)(pTHX_ PerlIO *f);

Allocate (if not already done so) the read buffer for this layer and return pointer to it. Return NULL on failure.

この層の読み込みバッファを割り当て(まだ割り当てていない場合)、この層へのポインタを返します。 失敗した場合はNULLを返します。 (TBR)

Get_bufsiz

        Size_t  (*Get_bufsiz)(pTHX_ PerlIO *f);

Return the number of bytes that last Fill() put in the buffer.

直前の Fill() がバッファに設定したバイト数を返します。

Get_ptr

        STDCHAR *       (*Get_ptr)(pTHX_ PerlIO *f);

Return the current read pointer relative to this layer's buffer.

現在の層のバッファに関連する現在の読み込みポインタを返します。

Get_cnt

        SSize_t (*Get_cnt)(pTHX_ PerlIO *f);

Return the number of bytes left to be read in the current buffer.

現在のバッファで読み込まれるために残っているバイト数を返します。

Set_ptrcnt

        void    (*Set_ptrcnt)(pTHX_ PerlIO *f,
                              STDCHAR *ptr, SSize_t cnt);

Adjust the read pointer and count of bytes to match ptr and/or cnt. The application (or layer above) must ensure they are consistent. (Checking is allowed by the paranoid.)

ptrおよび/またはcntに一致するように、読み出しポインタおよびバイト数を調整する。 アプリケーション(またはその上の層)は、それらが一貫していることを確認する必要があります。 (チェックは被害妄想者によって許可されています) (TBR)

ユーティリティ¶

次の層を調べるには PerlIONext(PerlIO *f) を使います。

PerlIO*が有効であることをチェックするには、PerlIOValid(PerlIO*f)を使用します。 (これは単に、ポインタが非NULLであり、その背後にあるポインタが非NULLであることをチェックするだけです)。 (TBR)

PerlIOBase(PerlIO*f)は"Base"ポインタ、つまりPerlIOl*ポインタを返します。 (TBR)

PerlIOSelf(PerlIO*f,type)PerlIOBaseキャストを型に戻します。 (TBR)

Perl_PerlIO_or_Base(PerlIO*f,callback,base,failure,args)は、層fの関数から("Read"のようにIO関数の名前だけで)argsを使ってcallbackを呼び出すか、そのようなコールバックがない場合は、同じargsを使ってbaseバージョンのコールバックを呼び出すか、fが無効な場合はerrnoにEBADFを設定してfailureを返します。 (TBR)

Perl_PerlIO_or_fail(PerlIO*f,callback,failure,args)は、argsを指定して層fの関数のcallbackを呼び出すか、そのようなコールバックがない場合はerrnoにEINVALを設定します。 fが無効な場合はerrnoにEBADFを設定してfailureを返します。 (TBR)

Perl_PerlIO_or_Base_void(PerlIO*f,callback,base,args)は、argsを使って層fの関数のcallbackを呼び出すか、そのようなコールバックがない場合は同じargsを使ってbaseバージョンのコールバックを呼び出すか、fが無効な場合はerrnoにEBADFを設定します。 (TBR)

Perl_PerlIO_or_fail_void(PerlIO*f,callback,args)は、層fの関数のcallbackをargsで呼び出すか、そのようなコールバックがない場合はerrnoにEINVALを設定します。 fが無効な場合はerrnoにEBADFを設定します。 (TBR)

PerlIO 層の実装¶

実装文書が不明確または十分でない場合は、次のような既存のPerlIO層実装を確認してください。 (TBR)

• C implementations

  The perlio.c and perliol.h in the Perl core implement the "unix", "perlio", "stdio", "crlf", "utf8", "byte", "raw", "pending" layers, and also the "mmap" and "win32" layers if applicable. (The "win32" is currently unfinished and unused, to see what is used instead in Win32, see "Querying the layers of filehandles" in PerlIO .)

  Perlコアのperlio.cとperliol.hは、"unix","perlio","stdio","crlf","utf8","byte","raw","pending"層と、"mmap"と"Win32"層を実装しています("Win32"は現在未完成で未使用です。 Win32で何が使われているかは"Querying the layers of filehandles" in PerlIOを参照してください)。 (TBR)

  PerlIO::encoding, PerlIO::scalar, PerlIO::via in the Perl core.

  Perl コアの PerlIO::encoding, PerlIO::scalar, PerlIO::via。

  PerlIO::gzip and APR::PerlIO (mod_perl 2.0) on CPAN.

  CPAN の PerlIO::gzip と APR::PerlIO (mod_perl 2.0)。

• Perl implementations

  PerlIO::via::QuotedPrint in the Perl core and PerlIO::via::* on CPAN.

  Perl コアの PerlIO::via::QuotedPrint と CPAN の PerlIO::via::*。

PerlIO層を作成する場合は、怠惰にする、つまり、目的のメソッドのみを実装する必要があります。 他のメソッドは、「ブランク」メソッドに置き換えることができます。 (TBR)

    PerlIOBase_noop_ok
    PerlIOBase_noop_fail

(何も実行せず、それぞれ0と-1を返します)、または特定のメソッドでは、NULLメソッドを使用してデフォルトの動作を想定することができます。 Openメソッドは親層でヘルプを検索します。 次の表に動作を要約します: (TBR)

    method      behaviour with NULL

    Clearerr    PerlIOBase_clearerr
    Close       PerlIOBase_close
    Dup         PerlIOBase_dup
    Eof         PerlIOBase_eof
    Error       PerlIOBase_error
    Fileno      PerlIOBase_fileno
    Fill        FAILURE
    Flush       SUCCESS
    Getarg      SUCCESS
    Get_base    FAILURE
    Get_bufsiz  FAILURE
    Get_cnt     FAILURE
    Get_ptr     FAILURE
    Open        INHERITED
    Popped      SUCCESS
    Pushed      SUCCESS
    Read        PerlIOBase_read
    Seek        FAILURE
    Set_cnt     FAILURE
    Set_ptrcnt  FAILURE
    Setlinebuf  PerlIOBase_setlinebuf
    Tell        FAILURE
    Unread      PerlIOBase_unread
    Write       FAILURE

 FAILURE        Set errno (to EINVAL in UNIXish, to LIB$_INVARG in VMS) and
                return -1 (for numeric return values) or NULL (for pointers)
 INHERITED      Inherited from the layer below
 SUCCESS        Return 0 (for numeric return values) or a pointer 

コア層¶

ファイル perlio.c は以下の層を提供します:

"unix"

A basic non-buffered layer which calls Unix/POSIX read(), write(), lseek(), close(). No buffering. Even on platforms that distinguish between O_TEXT and O_BINARY this layer is always O_BINARY.

Unix/POSIX read(),write(),lseek(),close()を呼び出す基本的な非バッファ層。 バッファリングなし。 O_TEXTとO_BINARYを区別するプラットフォームでも、この層は常にO_BINARYである。 (TBR)

"perlio"

A very complete generic buffering layer which provides the whole of PerlIO API. It is also intended to be used as a "base class" for other layers. (For example its Read() method is implemented in terms of the Get_cnt()/Get_ptr()/Set_ptrcnt() methods).

PerlIO API全体を提供する非常に完全な汎用バッファリング層です。 他の層の"ベースクラス"として使用することも意図されています(例えば、Read()メソッドはGet_cnt()/Get_ptr()/Set_ptrcnt()メソッドとして実装されています)。 (TBR)

"perlio" over "unix" provides a complete replacement for stdio as seen via PerlIO API. This is the default for USE_PERLIO when system's stdio does not permit perl's "fast gets" access, and which do not distinguish between O_TEXT and O_BINARY.

"unix"上の"perlio"は、PerlIOに見られるstdioの完全な置き換えを提供します。 これは、システムのstdioがperlの"fast gets"アクセスを許可せず、O_TEXTとO_BINARYを区別しない場合のUSE_PERLIOのデフォルトです。 (TBR)

"stdio"

A layer which provides the PerlIO API via the layer scheme, but implements it by calling system's stdio. This is (currently) the default if system's stdio provides sufficient access to allow perl's "fast gets" access and which do not distinguish between O_TEXT and O_BINARY.

PerlIO APIを層スキーム経由で提供するが、システムのstdioを呼び出すことによって実装する層。 システムのstdioがperlの"fast gets"アクセスを可能にするのに十分なアクセスを提供し、O_TEXTとO_BINARYを区別しない場合、これが(現在)デフォルトです。 (TBR)

"crlf"

A layer derived using "perlio" as a base class. It provides Win32-like "\n" to CR,LF translation. Can either be applied above "perlio" or serve as the buffer layer itself. "crlf" over "unix" is the default if system distinguishes between O_TEXT and O_BINARY opens. (At some point "unix" will be replaced by a "native" Win32 IO layer on that platform, as Win32's read/write layer has various drawbacks.) The "crlf" layer is a reasonable model for a layer which transforms data in some way.

基本クラスとして"perlio"を使用して派生した画層。 CR、LF変換にWin32のような"\n"を提供します。 "perlio"の上に適用することも、バッファ層自体として使用することもできます。 "unix"上の"crlf"は、システムがO_TEXTとO_BINARYを区別して開く場合のデフォルトです。 (Win32の読み取り/書き込み層にはさまざまな欠点があるため、ある時点で"unix"はそのプラットフォーム上の"ネイティブ"Win32 IO層に置き換えられます。 "crlf"層は、何らかの方法でデータを変換する層の妥当なモデルです。 (TBR)

"mmap"

If Configure detects mmap() functions this layer is provided (with "perlio" as a "base") which does "read" operations by mmap()ing the file. Performance improvement is marginal on modern systems, so it is mainly there as a proof of concept. It is likely to be unbundled from the core at some point. The "mmap" layer is a reasonable model for a minimalist "derived" layer.

Configureがmmap()関数を検出した場合、この層は("base"として"perlio"とともに)提供されます。 この層はファイルをmmap()で"read"操作を行います。 現在のシステムではパフォーマンスの向上はわずかであるため、主に概念実証として存在します。 ある時点でコアから切り離される可能性があります。 "mmap"層は、ミニマリストの"derived"層の合理的なモデルです。 (TBR)

"pending"

An "internal" derivative of "perlio" which can be used to provide Unread() function for layers which have no buffer or cannot be bothered. (Basically this layer's Fill() pops itself off the stack and so resumes reading from layer below.)

"perlio"から"内部"派生したもので、バッファを持たない層や邪魔にならない層に対してUnread()関数を提供するために使用することができます(基本的にこの層のFill()はスタックから自身をポップし、下の層から読み取りを再開します)。 (TBR)

"raw"

A dummy layer which never exists on the layer stack. Instead when "pushed" it actually pops the stack removing itself, it then calls Binmode function table entry on all the layers in the stack - normally this (via PerlIOBase_binmode) removes any layers which do not have PERLIO_K_RAW bit set. Layers can modify that behaviour by defining their own Binmode entry.

層スタック上に存在しないダミー層。 "push"された場合、実際に自身を削除してスタックをポップする代わりに、スタック内のすべての層上でBinmode関数テーブルエントリを呼び出します-通常は(PerlIOBase_binmode経由で)PERLIO_K_RAWビットが設定されていない層を削除します。 層は独自のBinmodeエントリを定義することで、その動作を変更できます。 (TBR)

"utf8"

Another dummy layer. When pushed it pops itself and sets the PERLIO_F_UTF8 flag on the layer which was (and now is once more) the top of the stack.

別のダミー層。 プッシュされると、自身がポップし、スタックの一番上にあった(今はもう一度)層にPERLIO_F_UTF8フラグをセットする。 (TBR)

さらに、perlio.cは、クラスのテーブルスロットで使用することを目的としたPerlIOBase_xxxx()関数を数多く提供しており、これらは特定のメソッドに対して特別なことを行う必要はありません。 (TBR)

エクステンション層¶

層は拡張モジュールによって利用可能にすることができる。 未知の層に遭遇した場合、PerlIOコードは以下と同等の処理を行う: (TBR)

   use PerlIO 'layer';

layer が不明な層とします。 PerlIO.pm は以下を試します:

   require PerlIO::layer;

そのプロセスの後、層がまだ定義されていない場合、openは失敗します。 (TBR)

以下のエクステンション層は perl に組み込まれています:

":encoding"

   use Encoding;

makes this layer available, although PerlIO.pm "knows" where to find it. It is an example of a layer which takes an argument as it is called thus:

はこの層を利用可能にしますが、PerlIO.pmはその場所を「知っている」のです。 これは、引数を取る層の例です。 (TBR)

   open( $fh, "<:encoding(iso-8859-7)", $pathname );

":scalar"

Provides support for reading data from and writing data to a scalar.

スカラに対するデータの読み書き対応を提供します。

   open( $fh, "+<:scalar", \$scalar );

When a handle is so opened, then reads get bytes from the string value of $scalar, and writes change the value. In both cases the position in $scalar starts as zero but can be altered via seek, and determined via tell.

ハンドルがこのようにオープンされると、$scalarの文字列値からgetバイトを読み取り、値を変更する書き込みを行います。 どちらの場合も、$scalarの位置は0から始まりますが、seekで変更でき、tellで決定できます。 (TBR)

Please note that this layer is implied when calling open() thus:

open() を呼び出すときにこの層が暗示されていることにどうか注意してください; 従って:

   open( $fh, "+<", \$scalar );

":via"

Provided to allow layers to be implemented as Perl code. For instance:

Perl コードとして実装された層を使えるようにします。 例えば:

   use PerlIO::via::StripHTML;
   open( my $fh, "<:via(StripHTML)", "index.html" );

See PerlIO::via for details.

詳しくは PerlIO::via を参照してください。

TODO¶

この文書を改良するために行われる必要のあることです。

• Explain how to make a valid fh without going through open()(i.e. apply a layer). For example if the file is not opened through perl, but we want to get back a fh, like it was opened by Perl.

  open()を経由せずに有効なfhを作成する方法(層を適用する)を説明します。 例えば、ファイルがperlで開かれていない場合に、Perlで開かれたようにfhを取得したい場合などです。 (TBR)

  How PerlIO_apply_layera fits in, where its docs, was it made public?

  PerlIO_apply_layeraは、そのドキュメントのどこにどのように適合し、公開されましたか? (TBR)

  Currently the example could be something like this:

  現在の例は、次のようになります。 (TBR)

    PerlIO *foo_to_PerlIO(pTHX_ char *mode, ...)
    {
        char *mode; /* "w", "r", etc */
        const char *layers = ":APR"; /* the layer name */
        PerlIO *f = PerlIO_allocate(aTHX);
        if (!f) {
            return NULL;
        }
  
        PerlIO_apply_layers(aTHX_ f, mode, layers);
  
        if (f) {
            PerlIOAPR *st = PerlIOSelf(f, PerlIOAPR);
            /* fill in the st struct, as in _open() */
            st->file = file;
            PerlIOBase(f)->flags |= PERLIO_F_OPEN;
  
            return f;
        }
        return NULL;
    }

• fix/add the documentation in places marked as XXX.

  XXXとマークされた場所にドキュメントを修正/追加します。 (TBR)

• The handling of errors by the layer is not specified. e.g. when $! should be set explicitly, when the error handling should be just delegated to the top layer.

  層によるエラー処理は指定されていません。 例えば$!が明示的に設定されている場合や、エラー処理がトップ層に委任されている場合などです。 (TBR)

  Probably give some hints on using SETERRNO() or pointers to where they can be found.

  SETERRNO()を使うためのヒントや、それらがどこにあるかを示すポインタを提供するとよいでしょう。 (TBR)

• I think it would help to give some concrete examples to make it easier to understand the API. Of course I agree that the API has to be concise, but since there is no second document that is more of a guide, I think that it'd make it easier to start with the doc which is an API, but has examples in it in places where things are unclear, to a person who is not a PerlIO guru (yet).

  APIを理解しやすくするために、いくつかの具体的な例を示すことが役立つと思います。 もちろん、APIが簡潔である必要があることには同意しますが、ガイドに近い2番目のドキュメントはないので、PerlIOの第一人者ではない人に対して、APIであるが、物事が明確でない場所での例があるドキュメントから始める方が簡単だと思います。 (TBR)

POD ERRORS¶

Hey! The above document had some coding errors, which are explained below:

Around line 277:

Unterminated C< ... > sequence