1			/*
     2			 * This file was generated automatically by ExtUtils::ParseXS version 2.10 from the
     3			 * contents of via.xs. Do not edit this file, edit via.xs instead.
     4			 *
     5			 *	ANY CHANGES MADE HERE WILL BE LOST! 
     6			 *
     7			 */
     8			
     9			#line 1 "via.xs"
    10			#define PERL_NO_GET_CONTEXT
    11			#include "EXTERN.h"
    12			#include "perl.h"
    13			#include "XSUB.h"
    14			#ifdef PERLIO_LAYERS
    15			
    16			#include "perliol.h"
    17			
    18			typedef struct
    19			{
    20			 struct _PerlIO base;       /* Base "class" info */
    21			 HV *		stash;
    22			 SV *		obj;
    23			 SV *		var;
    24			 SSize_t	cnt;
    25			 IO *		io;
    26			 SV *		fh;
    27			 CV *PUSHED;
    28			 CV *POPPED;
    29			 CV *OPEN;
    30			 CV *FDOPEN;
    31			 CV *SYSOPEN;
    32			 CV *GETARG;
    33			 CV *FILENO;
    34			 CV *READ;
    35			 CV *WRITE;
    36			 CV *FILL;
    37			 CV *CLOSE;
    38			 CV *SEEK;
    39			 CV *TELL;
    40			 CV *UNREAD;
    41			 CV *FLUSH;
    42			 CV *SETLINEBUF;
    43			 CV *CLEARERR;
    44			 CV *mERROR;
    45			 CV *mEOF;
    46			 CV *BINMODE;
    47			 CV *UTF8;
    48			} PerlIOVia;
    49			
    50			#define MYMethod(x) #x,&s->x
    51			
    52			CV *
    53			PerlIOVia_fetchmethod(pTHX_ PerlIOVia * s, char *method, CV ** save)
    54			{
    55			    GV *gv = gv_fetchmeth(s->stash, method, strlen(method), 0);
    56			#if 0
    57			    Perl_warn(aTHX_ "Lookup %s::%s => %p", HvNAME_get(s->stash), method, gv);
    58			#endif
    59			    if (gv) {
    60				return *save = GvCV(gv);
    61			    }
    62			    else {
    63				return *save = (CV *) - 1;
    64			    }
    65			}
    66			
    67			/*
    68			 * Try and call method, possibly via cached lookup.
    69			 * If method does not exist return Nullsv (caller may fallback to another approach
    70			 * If method does exist call it with flags passing variable number of args
    71			 * Last arg is a "filehandle" to layer below (if present)
    72			 * Returns scalar returned by method (if any) otherwise sv_undef
    73			 */
    74			
    75			SV *
    76			PerlIOVia_method(pTHX_ PerlIO * f, char *method, CV ** save, int flags,
    77					 ...)
    78			{
    79			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
    80			    CV *cv =
    81				(*save) ? *save : PerlIOVia_fetchmethod(aTHX_ s, method, save);
    82			    SV *result = Nullsv;
    83			    va_list ap;
    84			    va_start(ap, flags);
    85			    if (cv != (CV *) - 1) {
    86				IV count;
    87				dSP;
    88				SV *arg;
    89				PUSHSTACKi(PERLSI_MAGIC);
    90				ENTER;
    91				SPAGAIN;
    92				PUSHMARK(sp);
    93				XPUSHs(s->obj);
    94				while ((arg = va_arg(ap, SV *))) {
    95				    XPUSHs(arg);
    96				}
    97				if (*PerlIONext(f)) {
    98				    if (!s->fh) {
    99					GV *gv = newGVgen(HvNAME_get(s->stash));
   100					GvIOp(gv) = newIO();
   101					s->fh = newRV_noinc((SV *) gv);
   102					s->io = GvIOp(gv);
   103				    }
   104				    IoIFP(s->io) = PerlIONext(f);
   105				    IoOFP(s->io) = PerlIONext(f);
   106				    XPUSHs(s->fh);
   107				}
   108				else {
   109				    PerlIO_debug("No next\n");
   110				    /* FIXME: How should this work for OPEN etc? */
   111				}
   112				PUTBACK;
   113				count = call_sv((SV *) cv, flags);
   114				if (count) {
   115				    SPAGAIN;
   116				    result = POPs;
   117				    PUTBACK;
   118				}
   119				else {
   120				    result = &PL_sv_undef;
   121				}
   122				LEAVE;
   123				POPSTACK;
   124			    }
   125			    va_end(ap);
   126			    return result;
   127			}
   128			
   129			IV
   130			PerlIOVia_pushed(pTHX_ PerlIO * f, const char *mode, SV * arg,
   131					 PerlIO_funcs * tab)
   132			{
   133			    IV code = PerlIOBase_pushed(aTHX_ f, mode, Nullsv, tab);
   134			    if (code == 0) {
   135				PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   136				if (!arg) {
   137				    if (ckWARN(WARN_LAYER))
   138					Perl_warner(aTHX_ packWARN(WARN_LAYER),
   139						    "No package specified");
   140				    errno = EINVAL;
   141				    code = -1;
   142				}
   143				else {
   144				    STRLEN pkglen = 0;
   145				    const char *pkg = SvPV(arg, pkglen);
   146				    s->obj = SvREFCNT_inc(arg);
   147				    s->stash = gv_stashpvn(pkg, pkglen, FALSE);
   148				    if (!s->stash) {
   149					s->obj =
   150					    newSVpvn(Perl_form(aTHX_ "PerlIO::via::%s", pkg),
   151						     pkglen + 13);
   152					SvREFCNT_dec(arg);
   153					s->stash = gv_stashpvn(SvPVX_const(s->obj), pkglen + 13, FALSE);
   154				    }
   155				    if (s->stash) {
   156					char lmode[8];
   157					SV *modesv;
   158					SV *result;
   159					if (!mode) {
   160					    /* binmode() passes NULL - so find out what mode is */
   161					    mode = PerlIO_modestr(f,lmode);
   162					}
   163					modesv = sv_2mortal(newSVpvn(mode, strlen(mode)));
   164					result = PerlIOVia_method(aTHX_ f, MYMethod(PUSHED), G_SCALAR,
   165							     modesv, Nullsv);
   166					if (result) {
   167					    if (sv_isobject(result)) {
   168						s->obj = SvREFCNT_inc(result);
   169						SvREFCNT_dec(arg);
   170					    }
   171					    else if (SvIV(result) != 0)
   172						return SvIV(result);
   173					}
   174					else {
   175					    goto push_failed;
   176					}
   177					modesv = (*PerlIONext(f) && (PerlIOBase(PerlIONext(f))->flags & PERLIO_F_UTF8))
   178			                           ? &PL_sv_yes : &PL_sv_no;
   179					result = PerlIOVia_method(aTHX_ f, MYMethod(UTF8), G_SCALAR, modesv, Nullsv);
   180					if (result && SvTRUE(result)) {
   181					    PerlIOBase(f)->flags |= PERLIO_F_UTF8;
   182					}
   183					else {
   184					    PerlIOBase(f)->flags &= ~PERLIO_F_UTF8;
   185					}
   186					if (PerlIOVia_fetchmethod(aTHX_ s, MYMethod(FILL)) ==
   187					    (CV *) - 1)
   188					    PerlIOBase(f)->flags &= ~PERLIO_F_FASTGETS;
   189					else
   190					    PerlIOBase(f)->flags |= PERLIO_F_FASTGETS;
   191				    }
   192				    else {
   193					if (ckWARN(WARN_LAYER))
   194					    Perl_warner(aTHX_ packWARN(WARN_LAYER),
   195							"Cannot find package '%.*s'", (int) pkglen,
   196							pkg);
   197			push_failed:
   198			#ifdef ENOSYS
   199					errno = ENOSYS;
   200			#else
   201			#ifdef ENOENT
   202					errno = ENOENT;
   203			#endif
   204			#endif
   205					code = -1;
   206				    }
   207				}
   208			    }
   209			    return code;
   210			}
   211			
   212			PerlIO *
   213			PerlIOVia_open(pTHX_ PerlIO_funcs * self, PerlIO_list_t * layers,
   214				       IV n, const char *mode, int fd, int imode, int perm,
   215				       PerlIO * f, int narg, SV ** args)
   216			{
   217			    if (!f) {
   218				f = PerlIO_push(aTHX_ PerlIO_allocate(aTHX), self, mode,
   219						PerlIOArg);
   220			    }
   221			    else {
   222				/* Reopen */
   223				if (!PerlIO_push(aTHX_ f, self, mode, PerlIOArg))
   224				    return NULL;
   225			    }
   226			    if (f) {
   227				PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   228				SV *result = Nullsv;
   229				if (fd >= 0) {
   230				    SV *fdsv = sv_2mortal(newSViv(fd));
   231				    result =
   232					PerlIOVia_method(aTHX_ f, MYMethod(FDOPEN), G_SCALAR, fdsv,
   233							 Nullsv);
   234				}
   235				else if (narg > 0) {
   236				    if (*mode == '#') {
   237					SV *imodesv = sv_2mortal(newSViv(imode));
   238					SV *permsv = sv_2mortal(newSViv(perm));
   239					result =
   240					    PerlIOVia_method(aTHX_ f, MYMethod(SYSOPEN), G_SCALAR,
   241							     *args, imodesv, permsv, Nullsv);
   242				    }
   243				    else {
   244					result =
   245					    PerlIOVia_method(aTHX_ f, MYMethod(OPEN), G_SCALAR,
   246							     *args, Nullsv);
   247				    }
   248				}
   249				if (result) {
   250				    if (sv_isobject(result))
   251					s->obj = SvREFCNT_inc(result);
   252				    else if (!SvTRUE(result)) {
   253					return NULL;
   254				    }
   255				}
   256				else {
   257				    /* Required open method not present */
   258				    PerlIO_funcs *tab = NULL;
   259				    IV m = n - 1;
   260				    while (m >= 0) {
   261					PerlIO_funcs *t =
   262					    PerlIO_layer_fetch(aTHX_ layers, m, NULL);
   263					if (t && t->Open) {
   264					    tab = t;
   265					    break;
   266					}
   267					m--;
   268				    }
   269				    if (tab) {
   270					if ((*tab->Open) (aTHX_ tab, layers, m, mode, fd, imode,
   271							  perm, PerlIONext(f), narg, args)) {
   272					    PerlIO_debug("Opened with %s => %p->%p\n", tab->name,
   273							 PerlIONext(f), *PerlIONext(f));
   274					    if (m + 1 < n) {
   275						/*
   276						 * More layers above the one that we used to open -
   277						 * apply them now
   278						 */
   279						if (PerlIO_apply_layera
   280						    (aTHX_ PerlIONext(f), mode, layers, m + 1,
   281						     n) != 0) {
   282						    /* If pushing layers fails close the file */
   283						    PerlIO_close(f);
   284						    f = NULL;
   285						}
   286					    }
   287					    /* FIXME - Call an OPENED method here ? */
   288					    return f;
   289					}
   290					else {
   291					    PerlIO_debug("Open fail %s => %p->%p\n", tab->name,
   292							 PerlIONext(f), *PerlIONext(f));
   293					    /* Sub-layer open failed */
   294					}
   295				    }
   296				    else {
   297				         PerlIO_debug("Nothing to open with");
   298					/* Nothing to do the open */
   299				    }
   300				    PerlIO_pop(aTHX_ f);
   301				    return NULL;
   302				}
   303			    }
   304			    return f;
   305			}
   306			
   307			IV
   308			PerlIOVia_popped(pTHX_ PerlIO * f)
   309			{
   310			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   311			    PerlIOVia_method(aTHX_ f, MYMethod(POPPED), G_VOID, Nullsv);
   312			    if (s->var) {
   313				SvREFCNT_dec(s->var);
   314				s->var = Nullsv;
   315			    }
   316			
   317			    if (s->io) {
   318				IoIFP(s->io) = NULL;
   319				IoOFP(s->io) = NULL;
   320			    }
   321			    if (s->fh) {
   322				SvREFCNT_dec(s->fh);
   323				s->fh = Nullsv;
   324				s->io = NULL;
   325			    }
   326			    if (s->obj) {
   327				SvREFCNT_dec(s->obj);
   328				s->obj = Nullsv;
   329			    }
   330			    return 0;
   331			}
   332			
   333			IV
   334			PerlIOVia_close(pTHX_ PerlIO * f)
   335			{
   336			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   337			    IV code = PerlIOBase_close(aTHX_ f);
   338			    SV *result =
   339				PerlIOVia_method(aTHX_ f, MYMethod(CLOSE), G_SCALAR, Nullsv);
   340			    if (result && SvIV(result) != 0)
   341				code = SvIV(result);
   342			    PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
   343			    return code;
   344			}
   345			
   346			IV
   347			PerlIOVia_fileno(pTHX_ PerlIO * f)
   348			{
   349			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   350			    SV *result =
   351				PerlIOVia_method(aTHX_ f, MYMethod(FILENO), G_SCALAR, Nullsv);
   352			    return (result) ? SvIV(result) : PerlIO_fileno(PerlIONext(f));
   353			}
   354			
   355			IV
   356			PerlIOVia_binmode(pTHX_ PerlIO * f)
   357			{
   358			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   359			    SV *result =
   360				PerlIOVia_method(aTHX_ f, MYMethod(BINMODE), G_SCALAR, Nullsv);
   361			    if (!result || !SvOK(result)) {
   362				PerlIO_pop(aTHX_ f);
   363				return 0;
   364			    }
   365			    return SvIV(result);
   366			}
   367			
   368			IV
   369			PerlIOVia_seek(pTHX_ PerlIO * f, Off_t offset, int whence)
   370			{
   371			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   372			    SV *offsv = sv_2mortal(sizeof(Off_t) > sizeof(IV)
   373						   ? newSVnv((NV)offset) : newSViv((IV)offset));
   374			    SV *whsv = sv_2mortal(newSViv(whence));
   375			    SV *result =
   376				PerlIOVia_method(aTHX_ f, MYMethod(SEEK), G_SCALAR, offsv, whsv,
   377						 Nullsv);
   378			#if Off_t_size == 8 && defined(CONDOP_SIZE) && CONDOP_SIZE < Off_t_size
   379			    if (result)
   380				return (Off_t) SvIV(result);
   381			    else
   382				return (Off_t) -1;
   383			#else
   384			    return (result) ? SvIV(result) : -1;
   385			#endif
   386			}
   387			
   388			Off_t
   389			PerlIOVia_tell(pTHX_ PerlIO * f)
   390			{
   391			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   392			    SV *result =
   393				PerlIOVia_method(aTHX_ f, MYMethod(TELL), G_SCALAR, Nullsv);
   394			    return (result)
   395				   ? (SvNOK(result) ? (Off_t)SvNV(result) : (Off_t)SvIV(result))
   396				   : (Off_t) - 1;
   397			}
   398			
   399			SSize_t
   400			PerlIOVia_unread(pTHX_ PerlIO * f, const void *vbuf, Size_t count)
   401			{
   402			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   403			    SV *buf = sv_2mortal(newSVpvn((char *) vbuf, count));
   404			    SV *result =
   405				PerlIOVia_method(aTHX_ f, MYMethod(UNREAD), G_SCALAR, buf, Nullsv);
   406			    if (result)
   407				return (SSize_t) SvIV(result);
   408			    else {
   409				return PerlIOBase_unread(aTHX_ f, vbuf, count);
   410			    }
   411			}
   412			
   413			SSize_t
   414			PerlIOVia_read(pTHX_ PerlIO * f, void *vbuf, Size_t count)
   415			{
   416			    SSize_t rd = 0;
   417			    if (PerlIOBase(f)->flags & PERLIO_F_CANREAD) {
   418				if (PerlIOBase(f)->flags & PERLIO_F_FASTGETS) {
   419				    rd = PerlIOBase_read(aTHX_ f, vbuf, count);
   420				}
   421				else {
   422				    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   423				    SV *buf = sv_2mortal(newSV(count));
   424				    SV *n = sv_2mortal(newSViv(count));
   425				    SV *result =
   426					PerlIOVia_method(aTHX_ f, MYMethod(READ), G_SCALAR, buf, n,
   427							 Nullsv);
   428				    if (result) {
   429					rd = (SSize_t) SvIV(result);
   430					Move(SvPVX(buf), vbuf, rd, char);
   431					return rd;
   432				    }
   433				}
   434			    }
   435			    return rd;
   436			}
   437			
   438			SSize_t
   439			PerlIOVia_write(pTHX_ PerlIO * f, const void *vbuf, Size_t count)
   440			{
   441			    if (PerlIOBase(f)->flags & PERLIO_F_CANWRITE) {
   442				PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   443				SV *buf = newSVpvn((char *) vbuf, count);
   444				SV *result =
   445				    PerlIOVia_method(aTHX_ f, MYMethod(WRITE), G_SCALAR, buf,
   446						     Nullsv);
   447				SvREFCNT_dec(buf);
   448				if (result)
   449				    return (SSize_t) SvIV(result);
   450				return -1;
   451			    }
   452			    return 0;
   453			}
   454			
   455			IV
   456			PerlIOVia_fill(pTHX_ PerlIO * f)
   457			{
   458			    if (PerlIOBase(f)->flags & PERLIO_F_CANREAD) {
   459				PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   460				SV *result =
   461				    PerlIOVia_method(aTHX_ f, MYMethod(FILL), G_SCALAR, Nullsv);
   462				if (s->var) {
   463				    SvREFCNT_dec(s->var);
   464				    s->var = Nullsv;
   465				}
   466				if (result && SvOK(result)) {
   467				    STRLEN len = 0;
   468				    const char *p = SvPV(result, len);
   469				    s->var = newSVpvn(p, len);
   470				    s->cnt = SvCUR(s->var);
   471				    return 0;
   472				}
   473				else
   474				    PerlIOBase(f)->flags |= PERLIO_F_EOF;
   475			    }
   476			    return -1;
   477			}
   478			
   479			IV
   480			PerlIOVia_flush(pTHX_ PerlIO * f)
   481			{
   482			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   483			    SV *result =
   484				PerlIOVia_method(aTHX_ f, MYMethod(FLUSH), G_SCALAR, Nullsv);
   485			    if (s->var && s->cnt > 0) {
   486				SvREFCNT_dec(s->var);
   487				s->var = Nullsv;
   488			    }
   489			    return (result) ? SvIV(result) : 0;
   490			}
   491			
   492			STDCHAR *
   493			PerlIOVia_get_base(pTHX_ PerlIO * f)
   494			{
   495			    if (PerlIOBase(f)->flags & PERLIO_F_CANREAD) {
   496				PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   497				if (s->var) {
   498				    return (STDCHAR *) SvPVX(s->var);
   499				}
   500			    }
   501			    return (STDCHAR *) Nullch;
   502			}
   503			
   504			STDCHAR *
   505			PerlIOVia_get_ptr(pTHX_ PerlIO * f)
   506			{
   507			    if (PerlIOBase(f)->flags & PERLIO_F_CANREAD) {
   508				PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   509				if (s->var) {
   510				    STDCHAR *p = (STDCHAR *) (SvEND(s->var) - s->cnt);
   511				    return p;
   512				}
   513			    }
   514			    return (STDCHAR *) Nullch;
   515			}
   516			
   517			SSize_t
   518			PerlIOVia_get_cnt(pTHX_ PerlIO * f)
   519			{
   520			    if (PerlIOBase(f)->flags & PERLIO_F_CANREAD) {
   521				PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   522				if (s->var) {
   523				    return s->cnt;
   524				}
   525			    }
   526			    return 0;
   527			}
   528			
   529			Size_t
   530			PerlIOVia_bufsiz(pTHX_ PerlIO * f)
   531			{
   532			    if (PerlIOBase(f)->flags & PERLIO_F_CANREAD) {
   533				PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   534				if (s->var)
   535				    return SvCUR(s->var);
   536			    }
   537			    return 0;
   538			}
   539			
   540			void
   541			PerlIOVia_set_ptrcnt(pTHX_ PerlIO * f, STDCHAR * ptr, SSize_t cnt)
   542			{
   543			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   544			    s->cnt = cnt;
   545			}
   546			
   547			void
   548			PerlIOVia_setlinebuf(pTHX_ PerlIO * f)
   549			{
   550			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   551			    PerlIOVia_method(aTHX_ f, MYMethod(SETLINEBUF), G_VOID, Nullsv);
   552			    PerlIOBase_setlinebuf(aTHX_ f);
   553			}
   554			
   555			void
   556			PerlIOVia_clearerr(pTHX_ PerlIO * f)
   557			{
   558			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   559			    PerlIOVia_method(aTHX_ f, MYMethod(CLEARERR), G_VOID, Nullsv);
   560			    PerlIOBase_clearerr(aTHX_ f);
   561			}
   562			
   563			IV
   564			PerlIOVia_error(pTHX_ PerlIO * f)
   565			{
   566			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   567			    SV *result =
   568				PerlIOVia_method(aTHX_ f, "ERROR", &s->mERROR, G_SCALAR, Nullsv);
   569			    return (result) ? SvIV(result) : PerlIOBase_error(aTHX_ f);
   570			}
   571			
   572			IV
   573			PerlIOVia_eof(pTHX_ PerlIO * f)
   574			{
   575			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   576			    SV *result =
   577				PerlIOVia_method(aTHX_ f, "EOF", &s->mEOF, G_SCALAR, Nullsv);
   578			    return (result) ? SvIV(result) : PerlIOBase_eof(aTHX_ f);
   579			}
   580			
   581			SV *
   582			PerlIOVia_getarg(pTHX_ PerlIO * f, CLONE_PARAMS * param, int flags)
   583			{
   584			    PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
   585			    return PerlIOVia_method(aTHX_ f, MYMethod(GETARG), G_SCALAR, Nullsv);
   586			}
   587			
   588			PerlIO *
   589			PerlIOVia_dup(pTHX_ PerlIO * f, PerlIO * o, CLONE_PARAMS * param,
   590				      int flags)
   591			{
   592			    if ((f = PerlIOBase_dup(aTHX_ f, o, param, flags))) {
   593				/* Most of the fields will lazily set themselves up as needed
   594				   stash and obj have been set up by the implied push
   595				 */
   596			    }
   597			    return f;
   598			}
   599			
   600			
   601			
   602			PERLIO_FUNCS_DECL(PerlIO_object) = {
   603			 sizeof(PerlIO_funcs),
   604			 "via",
   605			 sizeof(PerlIOVia),
   606			 PERLIO_K_BUFFERED|PERLIO_K_DESTRUCT,
   607			 PerlIOVia_pushed,
   608			 PerlIOVia_popped,
   609			 PerlIOVia_open, /* NULL, */
   610			 PerlIOVia_binmode, /* NULL, */
   611			 PerlIOVia_getarg,
   612			 PerlIOVia_fileno,
   613			 PerlIOVia_dup,
   614			 PerlIOVia_read,
   615			 PerlIOVia_unread,
   616			 PerlIOVia_write,
   617			 PerlIOVia_seek,
   618			 PerlIOVia_tell,
   619			 PerlIOVia_close,
   620			 PerlIOVia_flush,
   621			 PerlIOVia_fill,
   622			 PerlIOVia_eof,
   623			 PerlIOVia_error,
   624			 PerlIOVia_clearerr,
   625			 PerlIOVia_setlinebuf,
   626			 PerlIOVia_get_base,
   627			 PerlIOVia_bufsiz,
   628			 PerlIOVia_get_ptr,
   629			 PerlIOVia_get_cnt,
   630			 PerlIOVia_set_ptrcnt,
   631			};
   632			
   633			
   634			#endif /* Layers available */
   635			
   636			#ifndef PERL_UNUSED_VAR
   637			#  define PERL_UNUSED_VAR(var) if (0) var = var
   638			#endif
   639			
   640			#line 641 "via.c"
   641			#ifdef __cplusplus
   642			extern "C"
   643			#endif
   644			XS(boot_PerlIO__via); /* prototype to pass -Wmissing-prototypes */
   645			XS(boot_PerlIO__via)
   646	           2    {
   647	           2        dXSARGS;
   648			
   649	           2        PERL_UNUSED_VAR(cv); /* -W */
   650	           2        PERL_UNUSED_VAR(items); /* -W */
   651	           2        XS_VERSION_BOOTCHECK ;
   652			
   653			
   654			    /* Initialisation Section */
   655			
   656			#line 631 "via.xs"
   657			{
   658			#ifdef PERLIO_LAYERS
   659			 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_object));
   660			#endif
   661			}
   662			
   663			#line 664 "via.c"
   664			
   665			    /* End of Initialisation Section */
   666			
   667	           2        XSRETURN_YES;
   668			}
   669