PERLAPIO(1)      Perl Programmers Reference Guide     PERLAPIO(1)

NNAAMMEE
       perlapio - perl's IO abstraction interface.

SSYYNNOOPPSSIISS
           PerlIO *PerlIO_stdin(void);
           PerlIO *PerlIO_stdout(void);
           PerlIO *PerlIO_stderr(void);

           PerlIO *PerlIO_open(const char *,const char *);
           int     PerlIO_close(PerlIO *);

           int     PerlIO_stdoutf(const char *,...)
           int     PerlIO_puts(PerlIO *,const char *);
           int     PerlIO_putc(PerlIO *,int);
           int     PerlIO_write(PerlIO *,const void *,size_t);
           int     PerlIO_printf(PerlIO *, const char *,...);
           int     PerlIO_vprintf(PerlIO *, const char *, va_list);
           int     PerlIO_flush(PerlIO *);

           int     PerlIO_eof(PerlIO *);
           int     PerlIO_error(PerlIO *);
           void    PerlIO_clearerr(PerlIO *);

           int     PerlIO_getc(PerlIO *);
           int     PerlIO_ungetc(PerlIO *,int);
           int     PerlIO_read(PerlIO *,void *,size_t);

           int     PerlIO_fileno(PerlIO *);
           PerlIO *PerlIO_fdopen(int, const char *);
           PerlIO *PerlIO_importFILE(FILE *, int flags);
           FILE   *PerlIO_exportFILE(PerlIO *, int flags);
           FILE   *PerlIO_findFILE(PerlIO *);
           void    PerlIO_releaseFILE(PerlIO *,FILE *);

           void    PerlIO_setlinebuf(PerlIO *);

           long    PerlIO_tell(PerlIO *);
           int     PerlIO_seek(PerlIO *,off_t,int);
           int     PerlIO_getpos(PerlIO *,Fpos_t *)
           int     PerlIO_setpos(PerlIO *,Fpos_t *)
           void    PerlIO_rewind(PerlIO *);

           int     PerlIO_has_base(PerlIO *);
           int     PerlIO_has_cntptr(PerlIO *);
           int     PerlIO_fast_gets(PerlIO *);
           int     PerlIO_canset_cnt(PerlIO *);

           char   *PerlIO_get_ptr(PerlIO *);
           int     PerlIO_get_cnt(PerlIO *);
           void    PerlIO_set_cnt(PerlIO *,int);
           void    PerlIO_set_ptrcnt(PerlIO *,char *,int);
           char   *PerlIO_get_base(PerlIO *);
           int     PerlIO_get_bufsiz(PerlIO *);

DDEESSCCRRIIPPTTIIOONN
       Perl's source code should use the above functions instead
       of those defined in ANSI C's stdio.h.  The perl headers
       will #define them to the I/O mechanism selected at
       Configure time.

       The functions are modeled on those in stdio.h, but
       parameter order has been "tidied up a little".

       PPeerrllIIOO **
           This takes the place of FILE *. Like FILE * it should
           be treated as opaque (it is probably safe to assume it
           is a pointer to something).

       PPeerrllIIOO_<i>_ssttddiinn(()), PPeerrllIIOO_<i>_ssttddoouutt(()), PPeerrllIIOO_<i>_ssttddeerrrr(())
           Use these rather than stdin, stdout, stderr. They are
           written to look like "function calls" rather than
           variables because this makes it easier to make them
           function calls if platform cannot export data to
           loaded modules, or if (say) different "threads" might
           have different values.

       PPeerrllIIOO_<i>_ooppeenn((ppaatthh,, mmooddee)), PPeerrllIIOO_<i>_ffddooppeenn((ffdd,,mmooddee))
           These correspond to fopen()/fdopen() arguments are the
           same.

       PPeerrllIIOO_<i>_pprriinnttff((ff,,ffmmtt,,......)), PPeerrllIIOO_<i>_vvpprriinnttff((ff,,ffmmtt,,aa))
           These are fprintf()/vfprintf() equivalents.

       PPeerrllIIOO_<i>_ssttddoouuttff((ffmmtt,,......))
           This is printf() equivalent. printf is #defined to
           this function, so it is (currently) legal to use
           printf(fmt,...) in perl sources.

       PPeerrllIIOO_<i>_rreeaadd((ff,,bbuuff,,ccoouunntt)), PPeerrllIIOO_<i>_wwrriittee((ff,,bbuuff,,ccoouunntt))
           These correspond to fread() and fwrite(). Note that
           arguments are different, there is only one "count" and
           order has "file" first.

       PPeerrllIIOO_<i>_cclloossee((ff))

       PPeerrllIIOO_<i>_ppuuttss((ff,,ss)), PPeerrllIIOO_<i>_ppuuttcc((ff,,cc))
           These correspond to fputs() and fputc().  Note that
           arguments have been revised to have "file" first.

       PPeerrllIIOO_<i>_uunnggeettcc((ff,,cc))
           This corresponds to ungetc().  Note that arguments
           have been revised to have "file" first.

       PPeerrllIIOO_<i>_ggeettcc((ff))
           This corresponds to getc().

       PPeerrllIIOO_<i>_eeooff((ff))
           This corresponds to feof().

       PPeerrllIIOO_<i>_eerrrroorr((ff))
           This corresponds to ferror().

       PPeerrllIIOO_<i>_ffiilleennoo((ff))
           This corresponds to fileno(), note that on some
           platforms, the meaning of "fileno" may not match Unix.

       PPeerrllIIOO_<i>_cclleeaarreerrrr((ff))
           This corresponds to clearerr(), i.e., clears 'eof' and
           'error' flags for the "stream".

       PPeerrllIIOO_<i>_fflluusshh((ff))
           This corresponds to fflush().

       PPeerrllIIOO_<i>_tteellll((ff))
           This corresponds to ftell().

       PPeerrllIIOO_<i>_sseeeekk((ff,,oo,,ww))
           This corresponds to fseek().

       PPeerrllIIOO_<i>_ggeettppooss((ff,,pp)), PPeerrllIIOO_<i>_sseettppooss((ff,,pp))
           These correspond to fgetpos() and fsetpos(). If
           platform does not have the stdio calls then they are
           implemented in terms of PerlIO_tell() and
           PerlIO_seek().

       PPeerrllIIOO_<i>_rreewwiinndd((ff))
           This corresponds to rewind(). Note may be redefined in
           terms of PerlIO_seek() at some point.

       PPeerrllIIOO_<i>_ttmmppffiillee(())
           This corresponds to tmpfile(), i.e., returns an
           anonymous PerlIO which will automatically be deleted
           when closed.

       CCoo--eexxiisstteennccee wwiitthh ssttddiioo

       There is outline support for co-existence of PerlIO with
       stdio.  Obviously if PerlIO is implemented in terms of
       stdio there is no problem. However if perlio is
       implemented on top of (say) sfio then mechanisms must
       exist to create a FILE * which can be passed to library
       code which is going to use stdio calls.

       PPeerrllIIOO_<i>_iimmppoorrttFFIILLEE((ff,,ffllaaggss))
           Used to get a PerlIO * from a FILE *.  May need
           additional arguments, interface under review.

       PPeerrllIIOO_<i>_eexxppoorrttFFIILLEE((ff,,ffllaaggss))
           Given an PerlIO * return a 'native' FILE * suitable
           for passing to code expecting to be compiled and
           linked with ANSI C stdio.h.

           The fact that such a FILE * has been 'exported' is
           recorded, and may affect future PerlIO operations on
           the original PerlIO *.

       PPeerrllIIOO_<i>_ffiinnddFFIILLEE((ff))
           Returns previously 'exported' FILE * (if any).  Place
           holder until interface is fully defined.

       PPeerrllIIOO_<i>_rreelleeaasseeFFIILLEE((pp,,ff))
           Calling PerlIO_releaseFILE informs PerlIO that all use
           of FILE * is complete. It is removed from list of
           'exported' FILE *s, and associated PerlIO * should
           revert to original behaviour.

       PPeerrllIIOO_<i>_sseettlliinneebbuuff((ff))
           This corresponds to setlinebuf(). Use is deprecated
           pending further discussion. (Perl core uses it only
           when "dumping"; it has nothing to do with $| auto-
           flush.)

       In addition to user API above there is an "implementation"
       interface which allows perl to get at internals of PerlIO.
       The following calls correspond to the various FILE_xxx
       macros determined by Configure. This section is really of
       interest to only those concerned with detailed perl-core
       behaviour or implementing a PerlIO mapping.

       PPeerrllIIOO_<i>_hhaass_<i>_ccnnttppttrr((ff))
           Implementation can return pointer to current position
           in the "buffer" and a count of bytes available in the
           buffer.

       PPeerrllIIOO_<i>_ggeett_<i>_ppttrr((ff))
           Return pointer to next readable byte in buffer.

       PPeerrllIIOO_<i>_ggeett_<i>_ccnntt((ff))
           Return count of readable bytes in the buffer.

       PPeerrllIIOO_<i>_ccaannsseett_<i>_ccnntt((ff))
           Implementation can adjust its idea of number of bytes
           in the buffer.

       PPeerrllIIOO_<i>_ffaasstt_<i>_ggeettss((ff))
           Implementation has all the interfaces required to
           allow perl's fast code to handle <FILE> mechanism.

             PerlIO_fast_gets(f) = PerlIO_has_cntptr(f) && \
                                   PerlIO_canset_cnt(f) && \
                                   `Can set pointer into buffer'

       PPeerrllIIOO_<i>_sseett_<i>_ppttrrccnntt((ff,,pp,,cc))
           Set pointer into buffer, and a count of bytes still in
           the buffer. Should be used only to set pointer to
           within range implied by previous calls to
           PerlIO_get_ptr and PerlIO_get_cnt.

       PPeerrllIIOO_<i>_sseett_<i>_ccnntt((ff,,cc))
           Obscure - set count of bytes in the buffer.
           Deprecated.  Currently used in only doio.c to force
           count < -1 to -1.  Perhaps should be PerlIO_set_empty
           or similar.  This call may actually do nothing if
           "count" is deduced from pointer and a "limit".

       PPeerrllIIOO_<i>_hhaass_<i>_bbaassee((ff))
           Implementation has a buffer, and can return pointer to
           whole buffer and its size. Used by perl for --TT / --BB
           tests.  Other uses would be very obscure...

       PPeerrllIIOO_<i>_ggeett_<i>_bbaassee((ff))
           Return start of buffer.

       PPeerrllIIOO_<i>_ggeett_<i>_bbuuffssiizz((ff))
           Return total size of buffer.

29/Jul/1998            perl 5.005, patch 03                     1